Pruebas unitarias de C# con TUnit y .NET

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.

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.

Prerequisites

  • .NET 10 SDK o versiones posteriores.
  • El editor de texto o de código que elija.

TUnit se basa completamente en Microsoft. Testing.Platform (MTP) y no admite VSTest. En este tutorial se usa el modo MTP de dotnet test, que requiere el SDK de .NET 10.

Creación del proyecto de origen

Abra una ventana de terminal. Cree un directorio denominado unit-testing-using-tunit 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-tunit
    unit-testing-using-tunit.slnx
    /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.");
        }
    }
}

Vuelva a cambiar el directorio al directorio unit-testing-using-tunit. 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-tunit
    unit-testing-using-tunit.slnx
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests

Las plantillas de proyecto de TUnit no se incluyen en el SDK de .NET. Instálelos con el siguiente comando:

dotnet new install TUnit.Templates

Cambie el directorio al directorio PrimeService.Tests y cree un nuevo proyecto mediante el siguiente comando:

dotnet new TUnit

Note

Los nombres cortos de plantilla distinguen mayúsculas de minúsculas. Usa TUnit, no tunit.

El comando dotnet new crea un proyecto de prueba que usa TUnit como biblioteca de pruebas. El archivo PrimeService.Tests.csproj generado es un proyecto ejecutable que hace referencia al TUnit paquete (el número de versión puede diferir):

<PropertyGroup>
  <ImplicitUsings>enable</ImplicitUsings>
  <Nullable>enable</Nullable>
  <OutputType>Exe</OutputType>
  <TargetFramework>net10.0</TargetFramework>
</PropertyGroup>

<ItemGroup>
  <PackageReference Include="TUnit" Version="1.*" />
</ItemGroup>

El TUnit paquete incluye el marco de pruebas, la biblioteca de aserciones y el ejecutor de pruebas de MTP, por lo que el proyecto no necesita ningún otro paquete de prueba. La plantilla también agrega pruebas de ejemplo. Elimine todos los archivos .cs y el directorio Data del directorio PrimeService.Tests , ya que este tutorial los reemplaza por sus propias pruebas.

Ahora, agregue la biblioteca de clases PrimeService como otra dependencia al proyecto. Use el comando dotnet reference add:

dotnet reference add ../PrimeService/PrimeService.csproj

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

/unit-testing-using-tunit
    unit-testing-using-tunit.slnx
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests
        Test Source Files
        PrimeService.Tests.csproj

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

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

Configuración del modo MTP de dotnet test

Dado que TUnit no admite VSTest, dotnet test debe ejecutarse en su modo MTP. En el directorio unit-testing-using-tunit , cree un archivo global.json con el siguiente contenido:

{
    "test": {
        "runner": "Microsoft.Testing.Platform"
    }
}

Para obtener más información, consulte el modo MTP de dotnet test.

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 , cree un archivo PrimeService_IsPrimeShould.cs con el código siguiente:

namespace Prime.UnitTests.Services
{
    using Prime.Services;

    public class PrimeService_IsPrimeShould
    {
        private readonly PrimeService _primeService = new();

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

            await Assert.That(result).IsFalse();
        }
    }
}

El atributo [Test] indica que un método es un método de prueba. TUnit no necesita un atributo en la clase . Las aserciones de TUnit son asincrónicas, por lo que el método de prueba devuelve una Task y espera a Assert.That. El TUnit paquete agrega directivas globales using para sus espacios de nombres, por lo que el archivo no las necesita.

Note

La using Prime.Services; directiva está dentro del espacio de nombres a propósito. MTP genera el punto de entrada de la aplicación de prueba en el espacio de nombres raíz del proyecto, PrimeService.Tests. Ese espacio de nombres oculta la clase PrimeService de una directiva using de la parte superior del archivo, pero no de una dentro del espacio de nombres.

Guarde este archivo y ejecute el comando dotnet test para compilar las pruebas y la biblioteca de clases y ejecutar las pruebas. El proyecto de prueba TUnit contiene el punto de entrada del programa para ejecutar las pruebas. dotnet test inicia la aplicación de prueba mediante el proyecto de prueba unitaria que creó.

Se produce un error en la prueba. Aún 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-tunit, vuelva a ejecutar dotnet test de nuevo. 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 ha hecho que una prueba se apruebe, 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. TUnit proporciona el [Arguments] atributo para crear un conjunto de pruebas que ejecutan el mismo código, pero tienen argumentos de entrada diferentes.

En lugar de crear nuevas pruebas, aplique este atributo para crear una única prueba controlada por datos. Reemplace el método IsPrime_InputIs1_ReturnFalse por el siguiente código. 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:

[Test]
[Arguments(-1)]
[Arguments(0)]
[Arguments(1)]
public async Task IsPrime_ValuesLessThan2_ReturnFalse(int value)
{
    var result = _primeService.IsPrime(value);

    await Assert.That(result).IsFalse();
}

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 IsPrime en el archivo PrimeService.cs:

if (candidate < 2)

Siga iterando agregando más pruebas y código en la biblioteca principal.

Construiste una pequeña biblioteca y un conjunto 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.

Consulte también

  • Se actualizó por última vez el