Introdução ao teste de unidade

Artigo
01/19/2024

Use o Visual Studio para definir e executar testes de unidade para manter a integridade de código, assegurar a cobertura de código e localizar erros e falhas antes de seus clientes. Execute os testes de unidade frequentemente para ter certeza de que seu código está funcionando corretamente.

Neste artigo, o código usa C# e C++, as ilustrações estão em C#, mas os conceitos e recursos se aplicam às linguagens .NET, C++, Python, JavaScript e TypeScript.

Criar testes de unidade

Esta seção descreve como criar um projeto de teste de unidade.

Abra o projeto que você deseja testar no Visual Studio.

Para demonstrar um modelo de teste de unidade, este artigo testa um simples projeto de Console C# ou C++ "Hello World" chamado HelloWorld. O código do exemplo para um projeto desse tipo é o seguinte:
- .NET
- C++
```
namespace HelloWorld
{
   public class Program
   {
      public static void Main()
      {
         Console.WriteLine("Hello World!");
      }
   }
}
```
```
#include <iostream>

int main()
{
   std::cout << "Hello World!\n";
}
```
No Gerenciador de Soluções, selecione o nó da solução. Em seguida, na barra de menus superior, selecione Arquivo>Adicionar>Novo Projeto.
Na caixa de diálogo novo projeto, localize o projeto de teste de unidade a ser usado.

Digite teste na caixa de pesquisa para encontrar um modelo de projeto de teste de unidade para a estrutura de teste que você deseja usar, como MSTest (C#) ou o projeto teste de unidade nativa (C++) e selecione-o.

A partir do Visual Studio 2017 versão 14.8, as linguagens .NET incluem modelos internos para NUnit e xUnit. Para C++, neste exemplo, selecione o projeto Teste de Unidade Nativa, que usa o Microsoft Native Unit Test Framework. (Para usar uma estrutura de teste do C++ diferente, consulte Gravando testes de unidade para C/C++). Para Python, consulte Configurar o teste de unidade no código Python para configurar seu projeto de teste.

Dica

Somente para C#, você pode criar projetos de teste de unidade a partir do código, usando um método mais rápido. Para obter mais informações, consulte Criar projetos de teste de unidade e métodos de teste. Para usar esse método com o .NET Core ou o .NET Standard, o Visual Studio 2019 ou posterior é necessário.

A ilustração a seguir apresenta um teste de unidade MSTest, que tem suporte no .NET.

Clique em Avançar, escolha um nome para o projeto de teste e, em seguida, clique em Criar.

Clique em Avançar, escolha um nome para o projeto de teste e, em seguida, clique em Criar.

O projeto é adicionado à solução.
No projeto de teste de unidade, adicione uma referência ao projeto que você deseja testar clicando com o botão direito do mouse em Referências ou Dependências e, em seguida, escolhendo Adicionar Referência ou Adicionar Referência de Projeto.
Selecione o projeto que contém o código que você testará e clique em OK.

Adicione código ao método de teste de unidade.

Por exemplo, você pode usar o código a seguir selecionando a guia de documentação correta que corresponda à estrutura de teste: MSTest, NUnit ou xUnit (com suporte apenas no .NET) ou Estrutura de Teste de Unidade Nativa da Microsoft para C++.

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.IO;
using System;

namespace HelloWorldTests
{
   [TestClass]
   public class UnitTest1
   {
      private const string Expected = "Hello World!";
      [TestMethod]
      public void TestMethod1()
      {
         using (var sw = new StringWriter())
         {
            Console.SetOut(sw);
            HelloWorld.Program.Main();

            var result = sw.ToString().Trim();
            Assert.AreEqual(Expected, result);
         }
      }
   }
}

using NUnit.Framework;
using System.IO;
using System;

namespace HelloWorldTests
{
   public class Tests
   {
      private const string Expected = "Hello World!";

      [SetUp]
      public void Setup()
      {
      }
      [Test]
      public void TestMethod1()
      {
         using (var sw = new StringWriter())
         {
            Console.SetOut(sw);
            HelloWorld.Program.Main();

            var result = sw.ToString().Trim();
            Assert.AreEqual(Expected, result);
         }
      }
   }
}

using System;
using Xunit;
using System.IO;

namespace HelloWorldTests
{
    public class UnitTest1
    {
        private const string Expected = "Hello World!";
        [Fact]
        public void Test1()
        {
            using (var sw = new StringWriter())
            {
                Console.SetOut(sw);
                HelloWorld.Program.Main();

                var result = sw.ToString().Trim();
                Assert.Equal(Expected, result);
            }
        }
    }
}

#include "pch.h"
#include "CppUnitTest.h"
#include "../HelloWorldUnitTestCPP/HelloWorldUnitTestCPP.cpp"   // Update using your project name

using namespace Microsoft::VisualStudio::CppUnitTestFramework;

namespace HelloWorldTests
{
   TEST_CLASS(HelloWorldTests)
   {
   public:

      TEST_METHOD(TestMethod)
      {
         std::string expected = "Hello World!\n";

         std::stringstream buffer;
         std::streambuf* sbuf = std::cout.rdbuf(); // Save cout's buffer
         std::cout.rdbuf(buffer.rdbuf()); // Redirect cout to the stringstream buffer

         // Call main() in your test
         int result = main();

         // When finished, redirect cout to the original buffer 
         std::cout.rdbuf(sbuf);
         std::cout << "std original buffer: \n";
         std::cout << buffer.get();

         // Test
         Assert::AreEqual(expected, buffer.str());
      }
   };
}

Executar testes de unidade

Abra o Gerenciador de Testes.

Para abrir o Gerenciador de Testes, escolhaTeste>Gerenciador de Teste na barra de menu superior (ou pressione Ctrl + E, T).
Execute seus testes de unidade clicando em Executar Tudo (ou pressione Ctrl + R, V).

Depois de concluir os testes, uma marca de seleção verde indica que houve aprovação em um teste. Um ícone "x" vermelho indica falha em um teste.

Dica

Você pode usar o Gerenciador de Testes para executar testes de unidade do framework de testes interno (MSTest) ou de estruturas de teste de terceiros. Você pode agrupar os testes em categorias, filtrar a lista de testes, criar, salvar e executar playlists de testes. Você também pode depurar testes e analisar um teste de desempenho e cobertura de código.

Exibir resultados do teste de unidade ao vivo (Visual Studio Enterprise)

Se estiver usando a estrutura de teste do MSTest, do xUnit ou do NUnit no Visual Studio de 2017 ou posterior, você poderá ver os resultados em tempo real de seus testes de unidade.

Observação

Para seguir estas etapas, o Visual Studio Enterprise é necessário, juntamente com o código .NET e uma das seguintes estruturas de teste: MSTest, xUnit ou NUnit.

Ative o Live Unit Testing do menu Teste, escolhendo Teste>Live Unit Testing>Iniciar.
Exiba os resultados dos testes dentro da janela do editor de código conforme você escreve e edita o código.
Clique em um indicador de resultado do teste para obter mais informações, assim como os nomes dos testes que abordam esse método.

Para obter mais informações sobre o Live Unit Testing, veja Live Unit Testing.

Usar uma estrutura de teste de terceiros

Você pode executar testes de unidade no Visual Studio usando estruturas de teste de terceiros, como NUnit, Boost ou Google C++ Testing Framework, dependendo da linguagem de programação. Para usar uma estrutura de terceiros:

Use o Gerenciador de Pacotes NuGet para instalar o pacote do NuGet para a estrutura de sua escolha.
(.NET) A partir do Visual Studio 2017, versão 14.6, o Visual Studio inclui modelos de projeto de teste pré-configurados para estruturas de teste NUnit e xUnit. Os modelos também incluem os pacotes NuGet necessários para habilitar o suporte.
(C++) No Visual Studio 2017 e versões posteriores, algumas estruturas, como a Estrutura de Teste C++ do Google, já estão inclusas. Para obter mais informações, consulte Gravar testes de unidade para C/C++ no Visual Studio.

Para adicionar um projeto de teste de unidade:

Abra a solução que contém o código que você deseja testar.
Clique com o botão direito do mouse na solução no Gerenciador de Soluções e escolha Adicionar>Novo Projeto.
Selecione um modelo de projeto de teste de unidade.

Nesse exemplo, selecione NUnit

Clique em Avançar, nomeie o projeto e clique em Criar.

O modelo de projeto inclui referências de NuGet a NUnit e NUnit3TestAdapter.
Adicione uma referência do projeto de teste ao projeto que contém o código que você deseja testar.

Clique com o botão direito do mouse no projeto no Gerenciador de Soluções e selecione Adicionar>Referência. (Também é possível adicionar uma referência no menu do botão direito do nó Referências ou Dependências.)
Adicione código ao método de teste.
Execute o teste a partir do Gerenciador de Testes ou clicando com o botão direito do mouse no código de teste e escolhendo Executar Teste(s) (ou Ctrl + R, T).