Cómo Ejecutar Pruebas con Dotnet Test en .NET 10

¡Hola, desarrolladores .NET! ¿Listos para mejorar su juego de pruebas con la Plataforma de Pruebas de Microsoft (MTP) y .NET 10? Si han estado usando dotnet test con el tradicional ejecutor VSTest, prepárense: MTP está aquí para hacer sus pruebas más fluidas, rápidas y flexibles. En esta guía conversacional, exploraremos qué es MTP, también conocida como MicrosoftTestingPlatform, por qué es un avance respecto a VSTest y cómo aprovecharla con dotnet test en .NET 10 para construir pruebas robustas para sus proyectos. Les guiaré a través de los pasos que seguí para experimentar con esta configuración, desde un proyecto MSTest básico hasta una solución multiproyecto con un ejecutable independiente. ¡Sumerjámonos en el mundo de MTP, MicrosoftTestingPlatform, .NET 10, dotnet test y hagamos que las pruebas sean más fáciles y divertidas!

💡

¿Quiere una excelente herramienta de prueba de API que genere hermosa documentación de API?

¿Quiere una plataforma integrada y todo en uno para que su equipo de desarrolladores trabaje en conjunto con máxima productividad?

¡Apidog satisface todas sus demandas y reemplaza a Postman a un precio mucho más asequible!

button

Por qué las pruebas son importantes en el desarrollo .NET

Antes de ponernos manos a la obra, hablemos de por qué las pruebas son tan importantes. Ya sea que esté construyendo una pequeña aplicación o un sistema empresarial masivo, las pruebas aseguran que su código funcione como se espera, detectan errores tempranamente y le ahorran esas sesiones de depuración nocturnas. Las pruebas unitarias automatizadas, como las que crearemos con MSTest y MTP, le permiten verificar la funcionalidad, mejorar la calidad del código y facilitar la refactorización. Con las mejoras de rendimiento de .NET 10 y el moderno framework de pruebas de MTP, está listo para escribir pruebas que sean rápidas, confiables y fáciles de integrar en pipelines de CI/CD. ¿Listo para ver cómo? ¡Sigamos mi viaje!

¿Qué es la Plataforma de Pruebas de Microsoft (MTP)?

La Plataforma de Pruebas de Microsoft (MTP), o MicrosoftTestingPlatform, es el framework de pruebas de próxima generación de Microsoft, introducido para reemplazar al antiguo ejecutor VSTest. A diferencia de VSTest, que se basa en adaptadores complejos y ejecución basada en DLL, MTP ofrece una experiencia nativa y optimizada para ejecutar pruebas en .NET. Está integrado en .NET 10, lo que lo hace más rápido y flexible, con características como ejecutores de pruebas independientes y una mejor integración con dotnet test. MTP es compatible con MSTest, NUnit y xUnit, y está diseñado para flujos de trabajo modernos, incluyendo CI/CD y desarrollo multiplataforma. Puede pensarlo como el hermano más moderno y eficiente de VSTest, optimizado para las mejoras de rendimiento de .NET 10.

Paso 1: Configuración de un proyecto MSTest básico con MTP

Comencemos de forma sencilla creando un proyecto MSTest básico para ver MTP en acción. Así es como empecé:

Crear el proyecto:

Abra su terminal y genere un nuevo proyecto MSTest usando la CLI de .NET:

dotnet new mstest -n MyMtpTests

Esto crea una carpeta de proyecto MyMtpTests con un archivo de prueba predeterminado (UnitTest1.cs) y un archivo .csproj.

Verificar el archivo del proyecto:

El archivo MyMtpTests.csproj generado se ve algo así:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="coverlet.collector" Version="6.0.0" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
    <PackageReference Include="MSTest.TestAdapter" Version="3.1.1" />
    <PackageReference Include="MSTest.TestFramework" Version="3.1.1" />
  </ItemGroup>
</Project>

Esto configura un proyecto MSTest estándar con VSTest, usando Coverlet para la cobertura de código y Microsoft.NET.Test.Sdk para la ejecución de pruebas.

Ejecutar las pruebas:

Navegue a la carpeta del proyecto:

cd MyMtpTests

Ejecute la prueba predeterminada:

dotnet test

El ejecutor VSTest ejecuta la prueba de ejemplo en UnitTest1.cs, y verá la salida confirmando que la prueba pasó, junto con las estadísticas de cobertura de Coverlet.

¿Qué está pasando? Esta es una configuración tradicional usando VSTest, pero es una base sólida antes de actualizar a MTP. El proyecto ejecuta las pruebas como una DLL, lo cual está bien pero no es tan flexible como el enfoque ejecutable de MTP.

Paso 2: Evolucionando a un ejecutor de pruebas basado en ejecutable MTP

Ahora, hagamos las cosas más emocionantes cambiando al ejecutor ejecutable independiente de MTP, que le permite ejecutar pruebas sin dotnet test. Así es como lo hice:

Actualizar el archivo del proyecto:

Modifique MyMtpTests.csproj para habilitar MTP y crear un ejecutable:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
    <!-- Enable MTP runner and executable output -->
    <EnableMSTestRunner>true</EnableMSTestRunner>
    <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
    <OutputType>Exe</OutputType>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="coverlet.collector" Version="6.0.0" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
    <PackageReference Include="MSTest.TestFramework" Version="3.10.2" />
    <PackageReference Include="MSTest.TestAdapter" Version="3.10.2" />
  </ItemGroup>
  <ItemGroup>
    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
  </ItemGroup>
</Project>

Cambios clave:

<EnableMSTestRunner>true</EnableMSTestRunner>: Activa el ejecutor de pruebas de MTP.
<TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>: Asegura la compatibilidad con dotnet test.
<OutputType>Exe</OutputType>: Genera un ejecutable independiente en lugar de una DLL.

Construir el proyecto:

Ejecute:

dotnet build

Esto genera un ejecutable (por ejemplo, MyMtpTests.exe) en la carpeta bin/Debug/net8.0.

Ejecutar el ejecutable:

Navegue al directorio de salida:

cd bin/Debug/net8.0

Ejecute el ejecutable:
Windows: MyMtpTests.exe
macOS/Linux: ./MyMtpTests
¡Las pruebas se ejecutan como una aplicación de consola independiente, no se necesita dotnet test!

Por qué esto es genial: El enfoque ejecutable es perfecto para configuraciones personalizadas de CI/CD o entornos sin el SDK de .NET instalado. Es un cambio de juego para la flexibilidad, y MTP lo hace más rápido que VSTest al reducir la sobrecarga.

Paso 3: Avanzando con .NET 10 y pruebas multiproyecto

Para ver a MTP y .NET 10 brillar en un escenario del mundo real, construyamos una solución multiproyecto con una biblioteca de clases y pruebas. Así es como lo configuré:

Estructura final del proyecto:

MyMtpSolution/
│
├── MyLibrary/
│   ├── Calculator.cs
│   └── MyLibrary.csproj
│
├── MyLibrary.Tests/
│   ├── CalculatorTests.cs
│   └── MyLibrary.Tests.csproj
│
├── MyMtpSolution.sln
└── dotnet.config

1. Crear una solución:

Comience de nuevo con una solución:

dotnet new sln -n MyMtpSolution

2. Crear una biblioteca de clases:

Agregue un proyecto de biblioteca de clases:

dotnet new classlib -n MyLibrary

Implemente una clase Calculator en MyLibrary/Calculator.cs:

namespace MyLibrary
{
    public class Calculator
    {
        public int Add(int a, int b) => a + b;
        public int Subtract(int a, int b) => a - b;
        public int Multiply(int a, int b) => a * b;
        public int Divide(int a, int b) => 
            b == 0 ? throw new ArgumentException("Cannot divide by zero.") : a / b;
    }
}

3. Crear un proyecto de prueba:

Genere un proyecto MSTest:

dotnet new mstest -n MyLibrary.Tests

Agregue pruebas en MyLibrary.Tests/UnitTest1.cs:

using Microsoft.VisualStudio.TestTools.UnitTesting;
using MyLibrary;

namespace MyLibrary.Tests
{
    [TestClass]
    public class CalculatorTests
    {
        private Calculator _calculator;

        [TestInitialize]
        public void Setup()
        {
            _calculator = new Calculator();
        }

        [TestMethod]
        public void Add_ReturnsCorrectSum()
        {
            Assert.AreEqual(5, _calculator.Add(2, 3));
        }

        [TestMethod]
        public void Subtract_ReturnsCorrectDifference()
        {
            Assert.AreEqual(1, _calculator.Subtract(3, 2));
        }

        [TestMethod]
        public void Multiply_ReturnsCorrectProduct()
        {
            Assert.AreEqual(6, _calculator.Multiply(2, 3));
        }

        [TestMethod]
        public void Divide_ReturnsCorrectQuotient()
        {
            Assert.AreEqual(2, _calculator.Divide(6, 3));
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentException))]
        public void Divide_ByZero_ThrowsException()
        {
            _calculator.Divide(6, 0);
        }
    }
}

4. Agregar referencias de proyecto:

Vincule el proyecto de prueba a la biblioteca:

dotnet add MyLibrary.Tests reference MyLibrary

5. Agregar proyectos a la solución:

Incluya ambos proyectos en la solución:

dotnet sln MyMtpSolution.sln add MyLibrary/MyLibrary.csproj
dotnet sln MyMtpSolution.sln add MyLibrary.Tests/MyLibrary.Tests.csproj

6. Configurar para MTP:

Actualice MyLibrary.Tests.csproj para habilitar MTP:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
    <EnableMSTestRunner>true</EnableMSTestRunner>
    <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="coverlet.collector" Version="6.0.0" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
    <PackageReference Include="MSTest.TestFramework" Version="3.10.2" />
    <PackageReference Include="MSTest.TestAdapter" Version="3.10.2" />
  </ItemGroup>
  <ItemGroup>
    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
  </ItemGroup>
</Project>

Opcionalmente, actualice MyLibrary.csproj para mayor consistencia (aunque no es estrictamente necesario):

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
</Project>

7. Actualizar a .NET 10:

Descargue el SDK de .NET 10 desde dotnet.microsoft.com (asegúrese de que sea compatible con su sistema operativo: Windows, macOS o Linux).

Actualice ambos archivos .csproj para apuntar a .NET 10:

<TargetFramework>net10.0</TargetFramework>

8. Crear un archivo dotnet.config:

En la raíz de la solución, cree dotnet.config con:

[dotnet.test.runner]
name = "Microsoft.Testing.Platform"

Esto habilita la integración nativa de MTP con dotnet test en .NET 10.

9. Construir y ejecutar pruebas:

Desde la raíz de la solución:

dotnet test

MTP ejecuta las pruebas, aprovechando las optimizaciones de .NET 10. Verá la salida de todas las pruebas, incluyendo aprobado/fallido y estadísticas de cobertura.

Por qué esto es increíble: .NET 10 trae mejoras de rendimiento (JIT más rápido, mejor gestión de memoria), y la integración nativa de MTP elimina los puentes heredados de VSTest, haciendo que las pruebas sean más rápidas y confiables. La configuración multiproyecto imita las aplicaciones del mundo real, con una biblioteca y un proyecto de prueba separados.

Cómo .NET 10 y MTP mejoran las pruebas

MTP y .NET 10 llevan las pruebas al siguiente nivel:

Velocidad: El ejecutor nativo de MTP está optimizado para .NET 10, reduciendo el tiempo de inicio en comparación con VSTest.
Flexibilidad: Los ejecutables independientes hacen que las pruebas sean portátiles, ideales para configuraciones personalizadas de CI/CD o entornos en contenedores.
Escalabilidad: El soporte multiproyecto maneja soluciones complejas, con MTP asegurando una ejecución de pruebas consistente.
Características Modernas: La compilación AOT y las optimizaciones de memoria de .NET 10 hacen que las pruebas se ejecuten más rápido, mientras que MTP soporta características avanzadas como la ejecución de pruebas en paralelo y reporteros personalizados.

Los usuarios están entusiasmados con MTP: “¡Es como VSTest pero sin el equipaje, más rápido y limpio!” Con .NET 10, obtendrá un rendimiento de vanguardia, y MTP hace que dotnet test sea un placer.

Consejos para la resolución de problemas

¿Las pruebas no se ejecutan? Asegúrese de que el SDK de .NET 10 esté instalado y que TargetFramework esté configurado en net10.0.
¿MTP no está habilitado? Verifique que EnableMSTestRunner y TestingPlatformDotnetTestSupport estén en el .csproj o dotnet.config.
¿Falta cobertura? Verifique que coverlet.collector esté incluido y ejecute dotnet test --collect:"XPlat Code Coverage".
¿El ejecutable falla? Asegúrese de que OutputType sea Exe y ejecute dotnet build antes de ejecutar el .exe.

Conclusión

¡Ahora es un experto en el uso de MTP (MicrosoftTestingPlatform), .NET 10, dotnet test para construir una configuración de pruebas moderna! Desde un proyecto MSTest básico hasta una solución multiproyecto con un ejecutable independiente, ha visto cómo MTP supera a VSTest y cómo .NET 10 mejora el rendimiento. Intente agregar más pruebas, integrarlas en su pipeline de CI/CD o explorar las características avanzadas de MTP como la ejecución en paralelo. ¿Tiene configuraciones de prueba geniales? ¡Compártalas, mantengamos viva la pasión por las pruebas!

button