(I’ve learnt a lot more since I originally wrote this (for instance, how to debug your tests), so this is an updated version).

This weekend I was part of a team that took part in the annual Hack Manchester hackathon (and we won Best in Show! Yay!). We used .Net Core for our back end code, and we got stuck in the middle of the night trying to add tests to our solution. It turned out the solution was pretty simple, so I’m documenting it here.

Intro

• To get started with a vanilla ASP.Net Core app + WebAPI: Getting Started with .Net Core, ASP and WebAPI
• There are two versions below. The one you choose will probably depend on things like deployment pipelines. If you are doing anything other than a quick hack, Version 1 is probably better.
• To be perfectly honest, the only reason I moved from one to another was because I (mistakenly) thought I couldn’t debug the tests or run them in an IDE unless they were in a separate project. It turned out that the only thing preventing me was that I hadn’t installed the relevant extension (see “Debug the tests / run the tests from an IDE” below).
• Version 1:
  • Place tests in a separate project/folder
• Version 2:
  • Keep all the tests in same folder/project as the source. This is quicker / simpler.

Version 1 – keep tests in separate folder/project

• This version places tests in a separate project / folder. This is probably better if you want a deployment pipeline.
• NB If your source is currently in your root folder, then you’ll need to move it into a separate folder (eg a src folder). This is easy:
  • Close down any IDEs you have running
  • Create a new src folder
  • If you don’t have a *.sln file, create one by opening the project in Visual Studio or running the command: dotnet new sln
  • Edit your solution file so that your csproj is prefixed by its new folder name
    • For me that meant changing ” TimeTravelApi.csproj” to “src/TimeTravelApi.csproj”
  • Move everything except *.sln into your new src folder
• Create a separate tests folder in your root folder
• Navigate to your new tests folder
• Create the nunit project:
  • There are two ways of doing this.
    • The first way is to run this command: dotnet new “NUnit 3 Test Project”
    • The second way is to manually add three new packages: NUnit, Microsoft.NET.Test.Sdk and NUnit3TestAdapter – see below for how to do this manually.
• Add a reference to your source project:
  • Run this command (replace “YourProject” with your project name): dotnet add reference ../src/YourProject.csproj
  • If you get an error about “incompatible targeted frameworks” then:
    • Go into your tests.csproj and change the .Net version from 2.0 to 2.1 like this: <TargetFramework>netcoreapp2.1</TargetFramework>
    • Run this command to upgrade the nunit version: dotnet add package nunit -v 3.11.0
    • ! This works in Oct 2018, but it might be different in the future!
  • Add your new tests project to the solution:
    • Navigate back up to your root folder
    • Command: dotnet sln add ./tests/tests.csproj
  • Write and run some tests (see “Write and run some tests” below)

Version 2 – keep tests in same folder/project as source

• This version keeps all the tests in same folder/project as the source. This is quicker / simpler if you are trying to keep things small and simple.
• Add the necessary packages:
  • You can run the separate package commands on the command line (see below), but you’re probably better off using the dedicated nunit command.
  • Dedicated nunit command:
    • Command line: dotnet new “NUnit 3 Test Project”
  • Separate commands for each package (check versions – this was written Oct 2018):
    • Command line: dotnet add package nunit -v 3.11.0
    • Command line: dotnet add package Microsoft.NET.Test.Sdk -v 15.7.2
    • Command line: dotnet add package NUnit3TestAdapter -v 3.10.0
  • Add the following sub-element to a <PropertyGroup> element in your csproj file:
    • This: <GenerateProgramFile>false</GenerateProgramFile>
  • Write and run some tests (see “Write and run some tests” below)

Write and run some tests

• Write some tests
  • At the bottom of this post is a skeleton you can use – it’s all you need for a functioning test
  • Run the tests from the command line: dotnet test -v normal
    • If you don’t add -v normal, you won’t see any info about individual tests
    • You can just add -v n, but I prefer to write it in full so I can remember what it means
    • Other switches available:
      • -v q[uiet]
      • -v m[inimal]
      • -v n[ormal]
      • -v d[etailed]
      • -v diag[nostic]
    • More: https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-test?tabs=netcore21
  • Debug the tests / run the tests from an IDE:
    • In Visual Studio Code:
      • Install the .Net Core Test Explorer extension (from Preferences | Extensions)
        • Mac: in the Code menu
        • Windows: in the File menu
      • Now you will see “Run test” and “Debug test” options above every test.
    • In Visual Studio (Windows):
      • Install the NUnit test adaptor:
        • Tools | Extensions and Updates
        • Select online on the left
        • Search for NUnit
        • Find NUnit 3 Test Adaptor
        • Click Download
        • Close down Visual Studio AND Visual Studio Code
        • You will get a VSIX installer dialog
      • Run the tests:
        • The Test menu gives you options for running tests
        • Then Test | Windows | Test explorer will show you the results
      • Debug tests:
        • Test | Windows | Test explorer: right-click on a test and choose Debug selected tests

A skeleton NUnit test:

using NUnit.Framework;
namespace KiwilandRouteApplication.Tests
{
  [TestFixture]
  public class DummyTests
  {
    [Test]
    public void DemoTest()
    {
      Assert.True(true);
    }
  }
}