This blog post demonstrates how to get started with writing automated tests using DotNetCore and NUnit.
We'll create a class library which implements functionality of a simple calculator. It'll have methods to add, subtract, divide and multiply. We'll use Test Driven Development so we will be writing the tests first.
You should already have .NET Core 3 or above installed on your PC. I will be using Visual Studio Code on Windows and not Linux so, console command will have to be translated to their Unix equivalent if you are not using Windows.
Step 1 - Get our environment ready
mkdir TestingSample cd TestingSample dotnet new classlib -n Calculator dotnet new nunit -n CalculatorTests
This will create two projects. The main project is named Calculator and will contain the implementation of the calculator. The CalculatorTests project will contain the unit tests.
Step 2 - Create a Visual Studio Code workspace
A workspace can hold multiple folder. Since we have two projects each within it's own folder, a workspace is perfect for us. Fire up VSCode, ensure no folders are already open. Follow these steps:
- Select File -> Save Workspace As, save the workspace in the TestingSample directory created in Step 1.
- Select File -> Add Folder to Workspace, select the folder containing the Calculator projecr
- Select File -> Add Folder to Workspace, select the folder containing the CalculatorTests projecr
This is how the folder structure looks like in VSCode:
Step 3 - Include the Calculator projects in the CalculatorTest project
We need to include the Calculator project in the test project as we will be calling the Calculator's methods and checking the output. To do this, we need to modify the CalculatorTests\CalculatorTests.csproj file. We need to add the following line within an ItemGroup tag:
<ProjectReference Include="..\Calculator\Calculator.csproj" />
The entire Calculator.csproj should look like this:
<Project Sdk="Microsoft.NET.Sdk"> <PropertyGroup> <TargetFramework>netcoreapp3.1</TargetFramework> <IsPackable>false</IsPackable> </PropertyGroup> <ItemGroup> <PackageReference Include="NUnit" Version="3.12.0" /> <PackageReference Include="NUnit3TestAdapter" Version="3.16.1" /> <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0"/> <ProjectReference Include="..\Calculator\Calculator.csproj" /> </ItemGroup> </Project>
Step 4 - Write our first test
Since we'll follow Test Driven Development, we will write the test first and then write the actual code to implement the functionality. We'll first rename the file CalculatorTests\UnitTest1.cs to something more meaningful like Test.cs. Edit the code to create an instance of Calculator (which doesn't exists yet!). Note, we've also changed the namespace to something more meaningful.
using System.Runtime.CompilerServices;
using NUnit.Framework;
namespace TestSample
{
public class Tests
{
[SetUp]
public void Setup()
{
calc = new Calculator();
}
[Test]
public void Test1()
{
Assert.Pass();
}
private Calculator calc;
}
}
Open a command-prompt, change the current directory to CalculatorTests and buid the project using dotnet build. You should see error like Tests.cs(20,17): error CS0246: The type or namespace name 'Calculator'. This is fine, since we still have to create the Calculator class.
Step 5 - Implement the empty Calculator class
Create a new file called Calculator.cs in the Calculator folder. Here' how the code should look like
namespace TestSample
{
public class Calculator
{
}
}
Switch to the command-prompt, change the directory to the CalculatorTests folder. Build the CalculatorTests by running dotnet build.
This is great, we've actually written our first test and made it pass successfully. The test is having a Calculator which can be instantiated.
Step 6 - Implement the Add method
Following the TDD approach, we'll first write the test. We'll add the following method in the Tests.cs file.
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using NUnit.Framework;
namespace TestSample
{
public class Tests
{
[SetUp]
public void Setup()
{
calc = new Calculator();
}
[Test]
public void Add()
{
Assert.AreEqual(3, calc.Add(1, 2));
}
private Calculator calc;
}
}
We'll also implement the Add method in the Calculator.cs file:
namespace TestSample
{
public class Calculator
{
public int Add(int a, int b)
{
return a;
}
}
}
We'll now run the test by switching to the CalculatorTests folder in the command prompt and running dotnet test command.
Looks like we have a failed test. We need to correct the defect.
Step 7 - Correct the error
We'll now the correct mistake by changing the implementation of the Add() method in the Calculator.cs file.
namespace TestSample
{
public class Calculator
{
public int Add(int a, int b)
{
return a + b;
}
}
}
Re-run the test. We now see the the single unit test we have has passed. Yay!
References
- NUnit
- DotNet new command
- Source code used in this post