swirl
Home Software Blog Wallpapers Webtools
NUnit with .NET Core in VS-Code
Friday 13, November 2020   |   Post link

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:

Folder structure

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.

Compilation success

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.

Compilation success

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!

Compilation success

References




Comments

Posts By Year

2020 (9)
2019 (6)
2018 (8)
2017 (11)
2016 (6)
2015 (18)
2014 (2)
2013 (4)
2012 (2)

Posts By Category

.NET (3)
.NET Core (2)
ASP.NET MVC (4)
AWS API Gateway (1)
Android (1)
Architecture (1)
Azure (2)
Book review (3)
Business (1)
C# (3)
C++ (1)
Containers (3)
Corporate culture (1)
Database (3)
Database migration (1)
Desktop (1)
DotNet (2)
Entity Framework (3)
Git (2)
IIS (1)
JDBC (1)
Java (5)
Life (6)
Linux (1)
Lucene (1)
Multi-threading (1)
OData (1)
Office (1)
PHP (1)
PowerShell (2)
Programming (22)
Rants (5)
SQL (2)
SQL Server (1)
Software Engineering (1)
Software development (1)
Solr (1)
Sql Server (2)
Storage (1)
T-SQL (1)
TDD (1)
TSQL (5)
Tablet (1)
Technology (1)
Test Driven (1)
Unit Testing (1)
Unit Tests (1)
Utilities (2)
VC++ (1)
VMWare (1)
VSCode (1)
Visual Studio (2)
Wallpapers (1)
Windows (9)
XML (2)

Posts By Tags

.NET(5) API Gateway(1) ASP.NET(4) AWS(1) Adults(1) Advertising(1) Android(1) Anti-forgery(1) Azure(2) Backup(1) Beliefs(1) BlockingQueue(1) Book review(2) Books(1) Busy(1) C#(4) C++(3) CLR(1) CORS(1) CSRF(1) CTE(1) Callbacks(1) Checkbox(1) Cmdlet(1) Commons(1) Company culture(1) Complexity(1) Consumer(1) Consumerism(1) Containers(3) Core(2) DPI(1) Data-time(1) Database(4) Debugging(1) Delegates(1) Developer(2) Dockers(2) DotNetCore(3) EF 1.0(1) Entity framework(1) Events(1) File copy(1) File history(1) Font(1) Git(2) GradleApache(1) HierarchyID(1) IIS(1) Installing(1) Intelli J(1) JDBC(1) JSON(1) JUnit(1) Java(1) JavaScript(1) Linux(1) Localization(1) Log4J(1) Lucene(1) MVC(4) Management(2) Migration history(1) Mobile Apps(1) Modern Life(1) Money(1) NUnit(1) OData(1) OPENXML(1) Objects(1) Office(1) Organization(1) PHP(1) Paths(1) PowerShell(2) Producer(1) Programming(1) Python(1) Quality(1) REDIS(2) Runtimes(1) SD card(1) SQL(2) SQL Code-first Migration(1) SSH(1) Sattelite assemblies(1) School(1) Self reliance(1) Shell(1) Solr(1) Sony VAIO(1) Spirituality(1) Sql Express(1) System Image(1) TDD(1) TSQL(3) Table variables(1) Tables(1) Tablet(1) Url rewrite(1) VMWare(1) VSCode(1) Validation(2) Wallpaper(1) Wallpapers(1) Web Development(4) Windows(2) Windows 10(2) Windows 2016(2) Windows 8.1(1) Work culture(1) XML(1) Yii(1)