Quantcast
Channel: Infragistics Community
Viewing all articles
Browse latest Browse all 2374

Getting started with .NET unit testing using NUnit

$
0
0


It’s usually good practice to have automated unit tests while developing your code. Doing so helps you find bugs early in the development cycle and saves you time in the long run. These tests can be run by the developer multiple times to verify the behavior of a particular unit of code for different sets of input.

Unit tests essentially check the behavior of a particular unit of the code or the function, and are written by the developers who are implementing the functionalities.

 

 

 

 

 

 

We test the behavior of a function before it becomes part of the whole system and goes to production by writing a piece of code to test this behavior under different conditions. Usually a function gets tested in isolation with the other functions of the system under test (SUT).

In .NET, there are two options to write Unit Tests:

1.       Using MS Test

2.       Using NUnit

 

In this article, we will learn to start Unit testing of C# classes using NUnit. We will walk through:

·         Creating the system under test

·         Setting up NUnit

·         Creating the Test project

·         Creating Test classes and methods

·         Different options of running the tests

·         Understanding TestFixtures and TestTearDown

·         Working with Ignore test

 

System under Test

 

In this example, we are going to write a Unit Test for a Calculator system. Let’s say the interface of the Calculator is defined as shown in the listing below:

 

namespace Calculator

{

   publicinterfaceICalculator

    {

       int Add(int num1, int num2);

       int Mul(int num1, int num2);

    }

}

 

 

The Calculator class is implemented as shown in the listing below:

 

namespace Calculator

{

  publicclassCalculator :ICalculator

    {

 

        publicint Add(int num1, int num2)

        {

            int result = num1 + num2;

            return result;

        }

 

        publicint Mul(int num1, int num2)

        {

            int result = num1 + num2;

            return result;

        }

    }

}

 

You’ll notice that we have implemented Mul function incorrectly on purpose.

To start working with NUnit and writing the test, we need to follow the following steps:

1.       Create a test project

2.       Add a reference of NUnit library

3.       Add a reference of System under test project

4.       Create a test class and write test method

 

Setting up the test project

To create a test project, add a class library project as shown in the listing below. Usually we should follow the naming convention to name the test project as: ProjectUnderTest.Test. Here we are going to test the Calculator project, so the name of the test project should be Calculator.Test.

 

Once a Test project is created you have two options to add a reference to NUnit in the project:

1.       Using the extension and updates

2.       Using the NuGet package

To work with extensions and updates, click on the Tool->Extension and Updates and then select NUnit Test Adapter.

To work with the NuGet package, right click on the project and from the context menu select the option of Manage NuGet packages. In the NuGet package manager, search for the NUnit and install NUnit Test Adapter for VS and NUnit in the project as shown in the image below:

 

 

After installing the NUnit Test Adapter, we can work with NUnit.

 

Add reference of the System under test project

Next we need to add a reference of the Calculator project (system under test) in the test project. To add that right click on the test project and add a reference of the Calculator project.

 

 

Create Test class and Test methods

Before we go ahead and create a test class and test methods, let us understand the structure of the test project. Since our SUT project name is Calculator, we should name the test project as Calculator.Tests. The name of the class under the test is Calculator, so the name of the test should be CalculatorTest. Finally, the name of the test function should be the name of the function under the test, prepended by the word “should”. The idea here is to give a readable name to the test project, class and function.

The relationship between the SUT project and the test project can be depicted as shown in the image below:

 

Next let us go ahead and create the Test Class and the Test Methods.  We need to use:

1.       TestFixture attribute to create the test class

2.       Test attribute to create the test method

 

A test class can be created as shown in the listing below:

 

using NUnit.Framework;

 

namespace Calculator.Tests

{

   [TestFixture]

   publicclassCalculatorTest

    {

       [Test]

       publicvoid ShouldAddTwoNumbers()

       {

           ICalculator sut = newCalculator();

           int expectedResult = sut.Add(7, 8);

           Assert.That(expectedResult, Is.EqualTo(15));

       }

 

       [Test]

       publicvoid ShouldMulTwoNumbers()

       {

           ICalculator sut = newCalculator();

           int expectedResult = sut.Mul(7, 8);

           Assert.That(expectedResult, Is.EqualTo(56));

       }

 

    }

}

 

 

In the above listing, we are:

1.       creating an object of the SUT Calculator class

2.       calling the methods

3.       asserting the result using NUnit assert (we will talk more about assert in later posts)

 After building the test project, we need to run the test.

 

Running the Test

There are three options to run the test:

1.       By using the Visual Studio Test Explorer

2.       By using the NUnit GUI

3.       By using the NUnit command prompt

 

Visual Studio Test Explorer

To use Visual Studio Test Runner, launch the Test Explorer by clicking on the TEST-WINDOWS-TEST EXPLORER option as shown in the image below:

 

 

You should able to see the unit test listed in the Test Explorer. You can either select a particular test and run it or choose to run all the tests. After running the tests of Calculator.Tests project, in the Test Explorer, the result can be seen as shown in the image below. We can see that ShouldAddTwoNumbers test is passed whereas ShouldMulTwoNumbers test is failed (which is expected).

 

NUnit GUI

You can download the MSI of NUnit GUI here. Once downloaded, install the NUnit GUI, and in the File menu, select the option of Open Project, then add DLL of the Calculator.Test project. After adding the DLL, you should able to see the tests loaded in the UI. To run a test, select and click on Run. In the NUnit UI you can clearly see the message for the failed test.

 

NUnit Command Prompt

Your third option to run the test is by using NUnit command prompt. Navigate to NUnit\Bin folder under the Program Files (its location depends on the installation path you selected) and run the file nunit-console.exe. In the double quotes, you need to pass the full path of the test project dll as the second parameter to run the test as shown in the image below:

 

 

 

The NUnit command prompt option is very useful for the continuous integration.

 

TestFixtureSetUp and TestFixtureTearDown

Two very important concepts of NUnit testing are Test Setup and Teardown. In the Calculator.Test, we are creating objects of the SUT Calculator in both tests. This is not the right practice. We should create all the objects required for the test before execution of any test. Other scenarios could be:

1.       Create a database connection before execution of first test

2.       Create an instance of a particular object before execution of first test

3.       Delete all connection to data base after execution of all the tests

4.       Delete a particular file from the system before execution of any test

We can solve the above scenarios using the TestFixtureSetUp and the TestFixtureTearDown. TestFixtureSetUp is a code which gets executed before the execution of any test, and the TestFixtureTearDown is a piece of code which gets executed after execution of all the tests.

 

Let us consider Calculator.Test. In the both tests, we are creating an object of the SUT Calculator. Whereas we need an object of the Calculator class before execution of any test and we need to dispose that after execution of all the tests. We can modify the test class as with SetUp and TearDown as shown in the listing below:

 

using NUnit.Framework;

 

namespace Calculator.Tests

{

 

   [TestFixture]

   publicclassCalculatorTest

    {

       ICalculator sut;

       [TestFixtureSetUp]

       publicvoid TestSetup()

       {

           sut = newCalculator();

       }

       [Test]

       publicvoid ShouldAddTwoNumbers()

       {

          

           int expectedResult = sut.Add(7, 8);

           Assert.That(expectedResult, Is.EqualTo(15));

       }

       [Test]

       publicvoid ShouldMulTwoNumbers()

       {

        

           int expectedResult = sut.Mul(7, 8);

           Assert.That(expectedResult, Is.EqualTo(56));

       }

 

       [TestFixtureTearDown]

       publicvoid TestTearDown()

       {

           sut = null;

       }

 

    }

}

 

 

In the above listing you will notice:

1.       There is a function attributed with [TestFixtureSetUp]. This function will be executed before the execution of any test. We are creating an object of the SUT Calculator inside this function such that the created instance will be available to all the tests.

2.       There is a function attributed with [TestFixtureTearDown]. This function will be executed after the execution of all the tests. We are disposing the object of SUT Calculator inside this function.

 

Ignore Test

Another scenario you may encounter while running a test is that you may want to ignore certain tests to be executed. For example, there are three tests and you want one of the test to be ignored while running the rest of your tests. This can be done by attributing the test to be ignored with the [ignore] attribute.

A test can be ignored as shown in the listing below:

 

 [Test]

       [Ignore]

       publicvoid ShouldNotMulTwoNumbers()

       {

 

           int expectedResult = sut.Mul(7, 8);

           Assert.That(expectedResult, Is.EqualTo(15));

       }

 

When you run all the tests in the test explorer, for the ignored test you will get the message as shown in the image below:

 

Conclusion

In this article we started doing Unit Test using NUnit in .NET. We learned about various components of  Unit testing using NUnit as shown in the points below:

·         Creating the system under test

·         Setting up NUnit

·         Creating the Test project

·         Creating Test classes and methods

·         Different options of running the tests

·         Understanding TestFixtures and TestTearDown.

·         Working with Ignore test.

I hope this article will help you in getting started with unit testing - thanks for reading and Happy Coding!

 

 


Viewing all articles
Browse latest Browse all 2374

Trending Articles