Compartir a través de

Pruebas unitarias de C# en .NET mediante dotnet test y xUnit

En este tutorial se muestra cómo crear una solución que contenga un proyecto de prueba unitaria y un proyecto de código fuente. Para seguir el tutorial mediante una solución precompilada, vea o descargue el código de ejemplo. Para obtener instrucciones de descarga, consulte Ejemplos y tutoriales.

Creación de la solución

En esta sección, se crea una solución que contiene los proyectos de origen y prueba. La solución completada tiene la siguiente estructura de directorios:

/unit-testing-using-dotnet-test
    unit-testing-using-dotnet-test.sln
    /PrimeService
        PrimeService.cs
        PrimeService.csproj
    /PrimeService.Tests
        PrimeService_IsPrimeShould.cs
        PrimeServiceTests.csproj

En las instrucciones siguientes se proporcionan los pasos para crear la solución de prueba. Consulte Comandos para crear una solución de prueba para obtener instrucciones para crear la solución de prueba en un paso.

  • Abra una ventana de terminal.

  • Ejecute el siguiente comando:

    dotnet new sln -o unit-testing-using-dotnet-test

    El dotnet new sln comando crea una nueva solución en el directorio unit-testing-using-dotnet-test .

  • Cambie el directorio a la carpeta unit-testing-using-dotnet-test .

  • Ejecute el siguiente comando:

    dotnet new classlib -o PrimeService

    El dotnet new classlib comando crea un nuevo proyecto de biblioteca de clases en la carpeta PrimeService . La nueva biblioteca de clases contendrá el código que se va a probar.

  • Cambie el nombre de Class1.cs a PrimeService.cs.

  • Reemplace el código de PrimeService.cs por el código siguiente:

    using System;

namespace Prime.Services
{
    public class PrimeService
    {
        public bool IsPrime(int candidate)
        {
            throw new NotImplementedException("Not implemented.");
        }
    }
}

    Actualmente, este código produce un NotImplementedException, pero implementará el método más adelante en el tutorial.

  • En el directorio unit-testing-using-dotnet-test , ejecute el siguiente comando para agregar el proyecto de biblioteca de clases a la solución:

    dotnet sln add ./PrimeService/PrimeService.csproj

  • Para crear el proyecto PrimeService.Tests , ejecute el siguiente comando:

    dotnet new xunit -o PrimeService.Tests

    El comando anterior crea el proyecto PrimeService.Tests en el directorio PrimeService.Tests . El proyecto de prueba usa xUnit como biblioteca de pruebas. El comando también configura el ejecutor de pruebas agregando los siguientes <PackageReference />elementos al archivo del proyecto:

    • Microsoft.NET.Test.Sdk
    • xunit
    • xunit.runner.visualstudio
    • coverlet.collector

  • Para agregar el proyecto de prueba al archivo de solución, ejecute el siguiente comando:

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

  • Agregue la PrimeService biblioteca de clases como dependencia al proyecto PrimeService.Tests :

    dotnet add ./PrimeService.Tests/PrimeService.Tests.csproj reference ./PrimeService/PrimeService.csproj

Comandos para crear la solución

En esta sección se resumen todos los comandos de la sección anterior. Omita esta sección si ha completado los pasos de la sección anterior.

Los comandos siguientes crean la solución de prueba en una máquina Windows. Para macOS y Unix, actualice el comando ren a la versión del sistema operativo ren para renombrar un archivo:

dotnet new sln -o unit-testing-using-dotnet-test
cd unit-testing-using-dotnet-test
dotnet new classlib -o PrimeService
ren .\PrimeService\Class1.cs PrimeService.cs
dotnet sln add ./PrimeService/PrimeService.csproj
dotnet new xunit -o PrimeService.Tests
dotnet add ./PrimeService.Tests/PrimeService.Tests.csproj reference ./PrimeService/PrimeService.csproj
dotnet sln add ./PrimeService.Tests/PrimeService.Tests.csproj

Siga las instrucciones para "Reemplazar el código en PrimeService.cs por el código siguiente" en la sección anterior.

Crear una prueba

Un enfoque popular en el desarrollo controlado por pruebas (TDD) es escribir una prueba (con errores) antes de implementar el código de destino. En este tutorial se usa el enfoque de TDD. El IsPrime método se puede llamar, pero no se implementa. Una llamada de prueba a IsPrime falla. Con TDD, se escribe una prueba que se sabe que fallará. A continuación, actualice el código de destino para que se supere la prueba. Sigue repitiendo este enfoque, escribiendo una prueba fallida y luego actualizando el código objetivo para que pase.

Actualice el proyecto PrimeService.Tests :

  • Elimine PrimeService.Tests/UnitTest1.cs.

  • Cree un archivo PrimeService.Tests/PrimeService_IsPrimeShould.cs .

  • Reemplace el código de PrimeService_IsPrimeShould.cs por el código siguiente:

    using Xunit;
using Prime.Services;

namespace Prime.UnitTests.Services
{
    public class PrimeService_IsPrimeShould
    {
        [Fact]
        public void IsPrime_InputIs1_ReturnFalse()
        {
            var primeService = new PrimeService();
            bool result = primeService.IsPrime(1);

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

El [Fact] atributo declara un método de prueba que ejecuta el ejecutor de pruebas. En la carpeta PrimeService.Tests , ejecute dotnet test. El comando dotnet test compila los proyectos y ejecuta las pruebas. El ejecutor de pruebas xUnit contiene el punto de entrada del programa para ejecutar las pruebas. dotnet test inicia el ejecutor de pruebas con el proyecto de prueba unitaria.

Se produce un error en la prueba porque IsPrime no se ha implementado. Con el enfoque de TDD, escriba solo código suficiente para que esta prueba pase. Actualice IsPrime con el siguiente código:

public bool IsPrime(int candidate)
{
    if (candidate == 1)
    {
        return false;
    }
    throw new NotImplementedException("Not fully implemented.");
}

Ejecute el dotnet test. Se supera la prueba.

Incorporación de más pruebas

Agregue pruebas de número primo para 0 y -1. Puede copiar la prueba creada en el paso anterior y realizar copias del código siguiente para probar 0 y -1. Pero no lo hagas, ya que hay una mejor manera.

var primeService = new PrimeService();
bool result = primeService.IsPrime(1);

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

Copiar código de prueba cuando solo un parámetro cambia da como resultado la duplicación de código y el sobredimensionamiento de pruebas. Los siguientes atributos xUnit permiten escribir un conjunto de pruebas similares:

  • [Theory] representa un conjunto de pruebas que ejecutan el mismo código, pero tienen argumentos de entrada diferentes.
  • [InlineData] atributo especifica valores para esas entradas.

En lugar de crear nuevas pruebas, aplique los atributos xUnit anteriores para crear una sola teoría. Reemplace el código siguiente...

[Fact]
public void IsPrime_InputIs1_ReturnFalse()
{
    var primeService = new PrimeService();
    bool result = primeService.IsPrime(1);

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

... con el código siguiente:

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

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

En el código anterior, [Theory] y [InlineData] habilite la prueba de varios valores inferiores a dos. Dos es el número primo más pequeño.

Agregue el código siguiente después de la declaración de clase y antes del [Theory] atributo :

private readonly PrimeService _primeService;

public PrimeService_IsPrimeShould()
{
    _primeService = new PrimeService();
}

Ejecute dotnet testy dos de las pruebas producirán un error. Para que se superen todas las pruebas, actualice el IsPrime método con el código siguiente:

public bool IsPrime(int candidate)
{
    if (candidate < 2)
    {
        return false;
    }
    throw new NotImplementedException("Not fully implemented.");
}

Después del enfoque de TDD, agregue más pruebas con errores y actualice el código de destino. Consulte la versión finalizada de las pruebas y la implementación completa de la biblioteca.

El método completado IsPrime no es un algoritmo eficaz para probar primalidad.

Recursos adicionales