Introducción a C# y MSTest

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 pregenerada, puede ver o descargar 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

• La versión más reciente del SDK de .NET
• Editor de Visual Studio Code
• El DevKit de C#

Creación del proyecto de origen

Abra una ventana de terminal. Cree un directorio denominado unit-testing-using-mstest para contener la solución. Dentro de este nuevo directorio, ejecute dotnet new sln para crear un nuevo archivo de solución para la biblioteca de clases y el proyecto de prueba. Cree un directorio PrimeService . En el esquema siguiente se muestra la estructura de directorios y archivos hasta ahora:

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

Convierta PrimeService en el directorio actual y ejecute dotnet new classlib para crear el proyecto de origen.

Cambie nuevamente el directorio al directorio unit-testing-using-mstest. Ejecute dotnet sln add para agregar el proyecto de biblioteca de clases a la solución:

dotnet sln add PrimeService/PrimeService.csproj

Cambie el nombre de Class1.cs en el directorio PrimeService a PrimeService.cs. Reemplace el código del archivo por el código siguiente para crear una implementación con errores de la PrimeService clase :

using System;

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

Creación del proyecto de prueba

Cree el directorio PrimeService.Tests . En el esquema siguiente se muestra la estructura de directorios:

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

Convierta el directorio PrimeService.Tests en el directorio actual y cree un nuevo proyecto mediante dotnet new mstest. El comando dotnet new crea un proyecto de prueba que usa MSTest como biblioteca de pruebas. La plantilla configura el ejecutor de pruebas en el archivo PrimeServiceTests.csproj :

<ItemGroup>
  <PackageReference Include="MSTest" Version="4.1.0" />
</ItemGroup>

El proyecto de prueba requiere otros paquetes para crear y ejecutar pruebas unitarias. dotnet new en el paso anterior se añadieron los paquetes y herramientas necesarios de MSTest para los informes de cobertura de código.

Agregue la PrimeService biblioteca de clases 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-mstest
    unit-testing-using-mstest.sln
    /PrimeService
        Source Files
        PrimeService.csproj
    /PrimeService.Tests
        Test Source Files
        PrimeServiceTests.csproj

Cambie al directorio unit-testing-using-mstest y ejecute dotnet sln add:

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

Creación de la primera prueba

Escribe una prueba fallida, haz que pase y luego repite el proceso. Quite UnitTest1.cs del directorio PrimeService.Tests y cree un nuevo archivo de C# denominado PrimeService_IsPrimeShould.cs con el siguiente contenido:

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Prime.Services;

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

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

        [TestMethod]
        public void IsPrime_InputIs1_ReturnFalse()
        {
            bool result = _primeService.IsPrime(1);

            Assert.IsFalse(result, "1 shouldn't be prime");
        }
    }
}

El atributo TestClass denota una clase que contiene pruebas unitarias. El atributo TestMethod indica que un método es un método de prueba.

MSTest crea una nueva instancia de la clase de prueba para cada prueba, por lo que el constructor crea un PrimeService independiente para cada prueba. El constructor solo contiene la configuración que necesita cada prueba de esta clase. Si las pruebas necesitan una configuración diferente, cree objetos en los métodos de prueba o llame a métodos auxiliares de esos métodos. Para obtener instrucciones, consulte Usar métodos auxiliares en lugar de configuración y desmontaje.

Guarde este archivo y ejecútelo dotnet test para compilar las pruebas y la biblioteca de clases y, a continuación, ejecute las pruebas. El ejecutor de pruebas de MSTest contiene el punto de entrada del programa para ejecutar las pruebas. dotnet test inicia el ejecutor de pruebas con el proyecto de prueba unitaria que creó.

La prueba falla porque todavía no has creado la implementación. Haga que esta prueba pase escribiendo el código más sencillo en la PrimeService clase 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-mstest, ejecute 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 TestMethod, pero eso se vuelve tedioso rápidamente. Hay otros atributos de MSTest que permiten escribir un conjunto de pruebas similares. Un método de prueba puede ejecutar el mismo código, pero tiene argumentos de entrada diferentes. Puede usar el atributo DataRow para especificar valores para esas entradas.

En lugar de crear nuevas pruebas, aplique estos dos atributos 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. Agregue un nuevo método de prueba en PrimeService_IsPrimeShould.cs:

[TestMethod]
[DataRow(-1)]
[DataRow(0)]
[DataRow(1)]
public void IsPrime_ValuesLessThan2_ReturnFalse(int value)
{
    bool result = _primeService.IsPrime(value);

    Assert.IsFalse(result, $"{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 IsPrime en el archivo PrimeService.cs:

if (candidate < 2)

Siga iterando agregando más pruebas, más teorías y más código en la biblioteca principal. Ya tiene la versión terminada de las pruebas y la implementación completa de la biblioteca.

Construiste una pequeña biblioteca y un conjunto de pruebas unitarias para esa biblioteca. Ha estructurado la solución para que la adición de nuevos paquetes y pruebas forme parte del flujo de trabajo normal. Ha concentrado la mayor parte de su tiempo y esfuerzo en resolver los objetivos de la aplicación.

Ejecutar pruebas en Azure Pipelines

Para ejecutar las pruebas automáticamente al hacer push de los cambios, agregue una configuración de Azure Pipelines al repositorio que contiene la solución completada. Necesita un proyecto de Azure DevOps y acceso a un agente hospedado por Microsoft. Para conocer los requisitos previos, consulte Crear su primera canalización.

1. En la raíz del repositorio, cree un azure-pipelines.yml archivo con el siguiente contenido. En el ejemplo se supone que los directorios PrimeService y PrimeService.Tests están en la raíz del repositorio y que ambos proyectos tienen como destino .NET 10.

   trigger:
   - main
   
   pool:
     vmImage: ubuntu-latest
   
   steps:
   - task: UseDotNet@2
     displayName: Install .NET SDK
     inputs:
       packageType: sdk
       version: 10.0.x
   
   - task: DotNetCoreCLI@2
     displayName: Run MSTest tests
     inputs:
       command: test
       projects: PrimeService.Tests/PrimeService.Tests.csproj
       arguments: --configuration Release
       publishTestResults: true
   

2. Ajuste la configuración para que coincida con su repositorio:

   • Si la rama tiene un nombre diferente, reemplace main en trigger por el nombre de la rama.
   • Si la solución está en un subdirectorio, actualice projects con la ruta del proyecto de prueba relativa al directorio raíz del repositorio.
   • Si los proyectos tienen como destino una versión de .NET diferente, cambie version en la tarea UseDotNet@2 para que coincida. Por ejemplo, use 8.0.x para proyectos que tienen como destino net8.0. Si el repositorio contiene un global.json archivo, asegúrese de que el SDK instalado cumple sus requisitos de versión.

3. Confirme los cambios y envíe la solución y el archivo azure-pipelines.yml a su directorio de Git.

4. En el proyecto de Azure DevOps, seleccione Canalizaciones>Nueva canalización, o Crear canalización si esta es su primera canalización. Seleccione el proveedor del repositorio y el repositorio.

5. En la página Configurar la canalización, seleccione Archivo YAML de Azure Pipelines existente, seleccione la rama y /azure-pipelines.yml y, a continuación, seleccione Continuar. Revise la configuración y seleccione Ejecutar.

La UseDotNet@2 tarea instala el SDK de .NET. La DotNetCoreCLI@2 tarea ejecuta dotnet test, que restaura las dependencias, compila el proyecto de prueba y su biblioteca a la que se hace referencia, y ejecuta las pruebas en la configuración Release.

Con publishTestResults: true, la tarea genera un archivo de resultados TRX y publica los resultados, incluso si una prueba se completa con errores. Después de la ejecución, abra la pestaña Pruebas de la ejecución del pipeline para revisar las pruebas superadas y con errores. Una prueba con error también hace que se produzca un error en la tarea de prueba y en la canalización.

Consulte también

• Microsoft.VisualStudio.TestTools.UnitTesting
• Uso del marco MSTest en pruebas unitarias
• Documentación del marco de pruebas de MSTest V2