Compartir a través de

Pruebas unitarias de C# con NUnit y .NET Core

Este tutorial le lleva a través de una experiencia interactiva que crea una solución de ejemplo paso a paso para aprender conceptos de pruebas unitarias. Si prefiere seguir el tutorial con una solución precompilada, vea o descargue el código de ejemplo antes de comenzar. Para obtener instrucciones de descarga, consulte Ejemplos y tutoriales.

En este artículo se trata de probar un proyecto de .NET Core. Si vas a probar un proyecto de ASP.NET Core, consulta Pruebas de integración en ASP.NET Core.

Prerrequisitos

Creación del proyecto de origen

Abra una ventana de terminal. Cree un directorio denominado unit-testing-using-nunit para contener la solución. Dentro de este nuevo directorio, ejecute el siguiente comando para crear un nuevo archivo de solución para la biblioteca de clases y el proyecto de prueba:

dotnet new sln

A continuación, cree un directorio PrimeService. En el esquema siguiente se muestra la estructura de directorios y archivos hasta ahora:

/unit-testing-using-nunit
    unit-testing-using-nunit.sln
    /PrimeService

Haga de PrimeService como el directorio actual y ejecute el siguiente comando para crear el proyecto fuente:

dotnet new classlib

Cambie el nombre de Class1.cs a PrimeService.cs. Crea una implementación fallida de la clase PrimeService.

using System;

namespace Prime.Services
{
    public class PrimeService
    {
        public bool IsPrime(int candidate)
        {
            throw new NotImplementedException("Please create a test first.");
        }
    }
}

Cambie nuevamente el directorio a unit-testing-using-nunit. Ejecute el siguiente comando para agregar el proyecto de biblioteca de clases a la solución:

dotnet sln add PrimeService/PrimeService.csproj

Creación del proyecto de prueba

A continuación, cree el directorio PrimeService.Tests. En el esquema siguiente se muestra la estructura de directorios:

/unit-testing-using-nunit
    unit-testing-using-nunit.sln
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests

Establezca el directorio PrimeService.Tests como el directorio actual y cree un nuevo proyecto con el siguiente comando:

dotnet new nunit

El comando dotnet new crea un proyecto de prueba que usa NUnit como biblioteca de pruebas. La plantilla generada configura el ejecutor de pruebas en el archivo PrimeService.Tests.csproj:

<ItemGroup>
  <PackageReference Include="nunit" Version="4.3.2" />
  <PackageReference Include="NUnit3TestAdapter" Version="5.0.0" />
  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
  <PackageReference Include="NUnit.Analyzers" Version="4.9.2">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
  </PackageReference>
</ItemGroup>

Nota:

Antes de .NET 9, el código generado puede hacer referencia a versiones anteriores del marco de prueba de NUnit. Puede usar la CLI de dotnet para actualizar los paquetes. Como alternativa, abra el archivo PrimeService.Tests.csproj y reemplace el contenido del grupo de elementos de referencias del paquete por el código anterior.

El proyecto de prueba requiere otros paquetes para crear y ejecutar pruebas unitarias. El comando dotnet new del paso anterior agregó el SDK de prueba de Microsoft, el marco de pruebas NUnit y el adaptador de prueba de NUnit. Ahora, agregue la biblioteca de clases PrimeService como otra dependencia al proyecto. Use el comando dotnet reference add:

dotnet reference add ../PrimeService/PrimeService.csproj

Puede ver todo el archivo en el repositorio de ejemplos de en GitHub.

En el esquema siguiente se muestra el diseño final de la solución:

/unit-testing-using-nunit
    unit-testing-using-nunit.sln
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests
        Test Source Files
        PrimeService.Tests.csproj

Ejecute el comando siguiente en el directorio unit-testing-using-nunit:

dotnet sln add ./PrimeService.Tests/PrimeService.Tests.csproj

Creación de la primera prueba

Escribe una prueba que falla, haz que pase y después repite el proceso. En el directorio PrimeService.Tests, cambie el nombre del archivo UnitTest1.cs a PrimeService_IsPrimeShould.cs y reemplace todo su contenido por el código siguiente:

using NUnit.Framework;
using Prime.Services;

namespace Prime.UnitTests.Services
{
    [TestFixture]
    public class PrimeService_IsPrimeShould
    {
        private PrimeService _primeService;

        [SetUp]
        public void SetUp()
        {
            _primeService = new PrimeService();
        }

        [Test]
        public void IsPrime_InputIs1_ReturnFalse()
        {
            var result = _primeService.IsPrime(1);

            Assert.That(result, Is.False, "1 should not be prime");
        }
    }
}

El atributo [TestFixture] denota una clase que contiene pruebas unitarias. El atributo [Test] indica que un método es un método de prueba.

Guarde este archivo y ejecute el comando dotnet test para compilar las pruebas y la biblioteca de clases y ejecutar las pruebas. El ejecutor de pruebas NUnit contiene el punto de entrada del programa para ejecutar las pruebas. dotnet test inicia el ejecutor de pruebas mediante el proyecto de prueba unitaria que ha creado.

Se produce un error en la prueba. Todavía no ha creado la implementación. Haga que la prueba pase escribiendo el código más sencillo en la clase PrimeService que funciona:

public bool IsPrime(int candidate)
{
    if (candidate == 1)
    {
        return false;
    }
    throw new NotImplementedException("Please create a test first.");
}

En el directorio unit-testing-using-nunit, vuelva a ejecutar dotnet test. El comando dotnet test ejecuta una compilación para el proyecto de PrimeService y, a continuación, para el proyecto de PrimeService.Tests. Después de compilar ambos proyectos, ejecuta esta única prueba. Pasa.

Adición de más características

Ahora que la prueba se ha superado, es el momento de escribir más. Hay algunos otros casos simples para números primos: 0, -1. Puede agregar nuevas pruebas con el atributo [Test], pero eso se vuelve tedioso rápidamente. Hay otros atributos NUnit que permiten escribir un conjunto de pruebas similares. Se usa un atributo [TestCase] para crear un conjunto de pruebas que ejecuten el mismo código, pero que tengan argumentos de entrada diferentes. Puede usar el atributo [TestCase] para especificar valores para esas entradas.

En lugar de crear nuevas pruebas, aplique este atributo para crear una única prueba controlada por datos. La prueba controlada por datos es un método que prueba varios valores inferiores a dos, que es el número primo más bajo:

[TestCase(-1)]
[TestCase(0)]
[TestCase(1)]
public void IsPrime_ValuesLessThan2_ReturnFalse(int value)
{
    var result = _primeService?.IsPrime(value);

    Assert.That(result, Is.False, $"{value} should not be prime");
}

Ejecute dotnet testy dos de estas pruebas fallan. Para que se superen todas las pruebas, cambie la cláusula if al principio del método Main en el archivo PrimeService.cs:

if (candidate < 2)

Siga iterando agregando más pruebas, teorías y código en la biblioteca principal. Tienes la versión finalizada de los tests y la implementación completa de la biblioteca.

Has creado una pequeña biblioteca y una suite de pruebas unitarias para esa biblioteca. También ha estructurado la solución para que la adición de nuevos paquetes y pruebas forme parte del flujo de trabajo estándar. Ha concentrado la mayor parte de su tiempo y esfuerzo en resolver los objetivos de la aplicación.