Blog

Como Executar Testes com Dotnet Test no .NET 10

Ashley Goolam

Ashley Goolam

27 agosto 2025

Como Executar Testes com Dotnet Test no .NET 10

Apidog para empresas

Implantação local

SSO & RBAC

Conforme SOC 2

Explorar Apidog Enterprise

Olá, desenvolvedores .NET! Prontos para elevar o nível dos seus testes com a Microsoft Testing Platform (MTP) e o .NET 10? Se você tem usado o dotnet test com o tradicional VSTest runner, prepare-se — a MTP chegou para tornar seus testes mais suaves, rápidos e flexíveis. Neste guia conversacional, exploraremos o que é a MTP, também conhecida como MicrosoftTestingPlatform, por que ela é um avanço em relação ao VSTest e como aproveitá-la com o dotnet test no .NET 10 para construir testes robustos para seus projetos. Vou guiá-lo pelos passos que segui para experimentar essa configuração, desde um projeto MSTest básico até uma solução multiprojeto com um executável autônomo. Vamos mergulhar no mundo da MTP, MicrosoftTestingPlatform, .NET 10, dotnet test e tornar os testes mais fáceis e divertidos!

💡
Quer uma ótima ferramenta de Teste de API que gera documentação de API bonita?

Quer uma plataforma integrada e completa para sua Equipe de Desenvolvedores trabalhar em conjunto com produtividade máxima?

Apidog atende a todas as suas demandas e substitui o Postman por um preço muito mais acessível!
button

Por Que os Testes São Importantes no Desenvolvimento .NET

Antes de colocarmos a mão na massa, vamos falar sobre a importância dos testes. Seja você construindo um aplicativo pequeno ou um sistema empresarial massivo, os testes garantem que seu código funcione como esperado, detectam bugs precocemente e o salvam daquelas sessões de depuração noturnas. Testes unitários automatizados, como os que criaremos com MSTest e MTP, permitem verificar a funcionalidade, melhorar a qualidade do código e tornar o refactoring uma tarefa simples. Com os aprimoramentos de desempenho do .NET 10 e a estrutura de teste moderna da MTP, você está pronto para escrever testes rápidos, confiáveis e fáceis de integrar em pipelines de CI/CD. Pronto para ver como? Vamos seguir minha jornada!

O Que É a Microsoft Testing Platform (MTP)?

A Microsoft Testing Platform (MTP), ou MicrosoftTestingPlatform, é a estrutura de teste de próxima geração da Microsoft, introduzida para substituir o antigo VSTest runner. Ao contrário do VSTest, que depende de adaptadores complexos e execução baseada em DLL, a MTP oferece uma experiência nativa e simplificada para executar testes no .NET. Ela é integrada ao .NET 10, tornando-a mais rápida e flexível, com recursos como executores de teste autônomos e melhor integração com dotnet test. A MTP suporta MSTest, NUnit e xUnit, e é projetada para fluxos de trabalho modernos, incluindo CI/CD e desenvolvimento multiplataforma. Você pode pensar nela como o irmão mais legal e eficiente do VSTest, otimizado para os aprimoramentos de desempenho do .NET 10.

Passo 1: Configurando um Projeto MSTest Básico com MTP

Vamos começar de forma simples, criando um projeto MSTest básico para ver a MTP em ação. Veja como eu comecei:

Criar o Projeto:

dotnet new mstest -n MyMtpTests

Verificar o Arquivo de Projeto:

<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>

Executar os Testes:

cd MyMtpTests

dotnet test
vstest runner

O Que Está Acontecendo? Esta é uma configuração tradicional usando VSTest, mas é uma base sólida antes de atualizarmos para a MTP. O projeto executa testes como uma DLL, o que é aceitável, mas não tão flexível quanto a abordagem de executável da MTP.

Passo 2: Evoluindo para um Executor de Testes Baseado em Executável MTP

Agora, vamos tornar as coisas mais emocionantes mudando para o executor de testes executável autônomo da MTP, que permite executar testes sem o dotnet test. Veja como eu fiz:

Atualizar o Arquivo de Projeto:

<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>

Principais mudanças:

Compilar o Projeto:

dotnet build
exe file generated

Executar o Executável:

cd bin/Debug/net8.0
run test on .exe file

Por Que Isso É Incrível: A abordagem executável é perfeita para configurações personalizadas de CI/CD ou ambientes sem o .NET SDK instalado. É um divisor de águas em termos de flexibilidade, e a MTP a torna mais rápida que o VSTest ao reduzir a sobrecarga.

Passo 3: Indo Além com .NET 10 e Testes Multiprojeto

Para ver a MTP e o .NET 10 brilharem em um cenário do mundo real, vamos construir uma solução multiprojeto com uma biblioteca de classes e testes. Veja como eu configurei:

Estrutura final do projeto:

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

1. Criar uma Solução:

dotnet new sln -n MyMtpSolution

2. Criar uma Biblioteca de Classes:

dotnet new classlib -n MyLibrary

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. Criar um Projeto de Teste:

dotnet new mstest -n MyLibrary.Tests

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. Adicionar Referências de Projeto:

dotnet add MyLibrary.Tests reference MyLibrary

5. Adicionar Projetos à Solução:

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

6. Configurar para 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>

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

7. Atualizar para .NET 10:

download .net10
<TargetFramework>net10.0</TargetFramework>

8. Criar um Arquivo dotnet.config:

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

9. Compilar e Executar Testes:

dotnet test
running the tests

Por Que Isso É Incrível: O .NET 10 traz melhorias de desempenho (JIT mais rápido, melhor gerenciamento de memória), e a integração nativa da MTP elimina as pontes legadas do VSTest, tornando os testes mais rápidos e confiáveis. A configuração multiprojeto imita aplicativos do mundo real, com uma biblioteca e um projeto de teste separado.

Como .NET 10 e MTP Melhoram os Testes

A MTP e o .NET 10 levam os testes para o próximo nível:

Os usuários estão entusiasmados com a MTP: “É como o VSTest, mas sem a bagagem — mais rápido e limpo!” Com o .NET 10, você obtém desempenho de ponta, e a MTP torna o dotnet test uma alegria.

Dicas de Solução de Problemas

Conclusão

Agora você é um profissional no uso da MTP (MicrosoftTestingPlatform), .NET 10, dotnet test para construir uma configuração de testes moderna! De um projeto MSTest básico a uma solução multiprojeto com um executável autônomo, você viu como a MTP supera o VSTest e como o .NET 10 impulsiona o desempenho. Tente adicionar mais testes, integrar em seu pipeline de CI/CD ou explorar os recursos avançados da MTP, como execução paralela. Tem configurações de teste legais? Compartilhe-as — vamos manter as boas vibrações de testes!

button

Pratique o design de API no Apidog

Descubra uma forma mais fácil de construir e usar APIs

Cadastre-se gratuitamenteBaixar