Introdução ao teste de unidade ao vivo

Quando ativa o Live Unit Testing numa solução Visual Studio, ele representa visualmente a sua cobertura de testes e o estado dos seus testes. O Live Unit Testing também executa testes dinamicamente sempre que modifica o seu código e notifica-o imediatamente quando as suas alterações causam falhas nos testes.

O Live Unit Testing pode ser usado para testar soluções que visam o .NET Framework, .NET Core ou .NET 5+. Neste tutorial, vais aprender a usar o Live Unit Testing criando uma biblioteca de classes simples que tem como alvo .NET, e vais criar um projeto MSTest que direciona .NET para o testar.

A solução completa em C# pode ser descarregada do repositório MicrosoftDocs/visualstudio-docs no GitHub.

Pré-requisitos

Este tutorial exige que tenha instalado a edição Visual Studio Enterprise com o workload de desenvolvimento .NET para desktop.

Crie a solução e o projeto da biblioteca da turma

Comece por criar uma solução Visual Studio chamada UtilityLibraries, que consiste num único projeto de biblioteca de classes .NET, StringLibrary.

A solução é apenas um contentor para um ou mais projetos. Para criar uma solução em branco, abra o Visual Studio e faça o seguinte:

Selecione Ficheiro>Novo>Projeto no menu principal do Visual Studio.
Escreve solução na caixa de pesquisa do modelo e depois seleciona o modelo de Solução em Branco . Nomeie o projeto como UtilityLibraries.
Termina de criar a solução.

Agora que criaste a solução, vais criar uma biblioteca de classes chamada StringLibrary que contém vários métodos de extensão para trabalhar com strings.

No Explorador de Soluções, clique com o botão direito na solução UtilityLibraries e selecione Adicionar>Novo Projeto.
Escreve a biblioteca de classes na caixa de pesquisa de modelos e depois seleciona o modelo de Biblioteca de Classes que tem como alvo .NET ou .NET Standard. Clique em Next.
Nomeie o projeto StringLibrary.
Clique em Criar para criar o projeto.

Substitua todo o código existente no editor de código pelo seguinte código:

using System;

namespace UtilityLibraries
{
    public static class StringLibrary
    {
        public static bool StartsWithUpper(this string s)
        {
            if (String.IsNullOrWhiteSpace(s))
                return false;

            return Char.IsUpper(s[0]);
        }

        public static bool StartsWithLower(this string s)
        {
            if (String.IsNullOrWhiteSpace(s))
                return false;

            return Char.IsLower(s[0]);
        }

        public static bool HasEmbeddedSpaces(this string s)
        {
            foreach (var ch in s.Trim())
            {
                if (ch == ' ')
                    return true;
            }
            return false;
        }
    }
}

A StringLibrary tem três métodos estáticos:

StartsWithUpper retorna true se uma cadeia começa com um carácter maiúsculo; caso contrário, retorna false.
StartsWithLower retorna true se uma cadeia começa com um carácter minúsculo; caso contrário, retorna false.
HasEmbeddedSpaces retorna true se uma cadeia contiver um carácter de espaço em branco embutido; caso contrário, devolve false.

Selecione Build>Build Solution no menu principal do Visual Studio. A build deve ter sucesso.

Criar o projeto de teste

O passo seguinte é criar o projeto de teste unitário para testar a biblioteca StringLibrary. Crie os testes unitários realizando os seguintes passos:

No Explorador de Soluções, clique com o botão direito na solução UtilityLibraries e selecione Adicionar>Novo Projeto.
Escreve teste unitário na caixa de pesquisa do template, seleciona C# como linguagem e depois seleciona o MSTest Unit Test Project para o template .NET. Clique em Next.

Observação

No Visual Studio 2019 versão 16.9, o nome do modelo de projeto MSTest é Projeto de Teste de Unidade.
Nomeie o projeto como StringLibraryTests e clique em Próximo.
Escolha a estrutura de destino recomendada ou .NET 8 e, em seguida, escolha Criar.

Observação

Este tutorial de introdução utiliza Testes Unitários ao Vivo com o framework de testes MSTest. Também podes usar os frameworks de teste xUnit e NUnit.
O projeto de teste unitário não consegue aceder automaticamente à biblioteca de classes que está a testar. Dá acesso à biblioteca de teste adicionando uma referência ao projeto da biblioteca de classes. Para isso, clique com o botão direito no StringLibraryTests projeto e selecione Adicionar>Referência do Projeto. No diálogo do Gestor de Referências , certifique-se de que o separador Solução está selecionado e selecione o projeto StringLibrary, como mostrado na ilustração seguinte.

Substitua o código de teste unitário padrão fornecido pelo modelo pelo seguinte código:

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

namespace StringLibraryTest
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestStartsWithUpper()
        {
            // Tests that we expect to return true.
            string[] words = { "Alphabet", "Zebra", "ABC", "Αθήνα", "Москва" };
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsTrue(result,
                              $"Expected for '{word}': true; Actual: {result}");
            }
        }

        [TestMethod]
        public void TestDoesNotStartWithUpper()
        {
            // Tests that we expect to return false.
            string[] words = { "alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                               "1234", ".", ";", " " };
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsFalse(result,
                               $"Expected for '{word}': false; Actual: {result}");
            }
        }

        [TestMethod]
        public void DirectCallWithNullOrEmpty()
        {
            // Tests that we expect to return false.
            string[] words = { String.Empty, null };
            foreach (var word in words)
            {
                bool result = StringLibrary.StartsWithUpper(word);
                Assert.IsFalse(result,
                               $"Expected for '{(word == null ? "<null>" : word)}': " +
                               $"false; Actual: {result}");
            }
        }
    }
}

Guarde o seu projeto selecionando o ícone de Guardar na barra de ferramentas.

Como o código de teste unitário inclui alguns caracteres não ASCII, verá o seguinte diálogo a avisar que alguns caracteres serão perdidos se guardar o ficheiro no seu formato ASCII predefinido.
Escolhe o botão Guardar com Outra Codificação .
Na lista suspensa de Codificação do diálogo opções avançadas de gravação, escolha Unicode (UTF-8 sem marca de ordem) - Página de códigos 65001, como mostra a ilustração seguinte.
Compile o projeto de teste unitário selecionando Build>Rebuild Solution no menu principal do Visual Studio.

Criaste uma biblioteca de classes, bem como alguns testes unitários para ela. Agora terminaste os preliminares necessários para usar o Live Unit Testing.

Permitir Testes Unitários ao Vivo

Até agora, embora tenhas escrito os testes para a biblioteca de classes StringLibrary, ainda não os executaste. O Live Unit Testing executa-os automaticamente assim que o ativas. Para isso, faça o seguinte:

Opcionalmente, selecione a janela do editor de código que contém o código para a StringLibrary. Isto é Class1.cs para um projeto C# ou Class1.vb para um projeto Visual Basic. (Este passo permite-lhe inspecionar visualmente o resultado dos seus testes e a extensão da cobertura do seu código assim que ativar o Live Unit Testing.)
Selecione Test>Live Unit Testing>Start no menu superior do Visual Studio.
Verifique a configuração para o Live Unit Testing, garantindo que a raiz do repositório inclui o caminho para os ficheiros fonte tanto do projeto utilitário como do projeto de teste. Selecione Próximo e depois Terminar.

Na janela de Testes Unitários ao Vivo, selecione o link incluir todos os testes (alternativamente, selecione o ícone do botão Playlist , depois selecione o StringLibraryTest, que seleciona todos os testes por baixo). Depois desmarca o botão Playlist para sair do modo de edição.)
O Visual Studio vai reconstruir o projeto e iniciar o Live Unit Test, que executa automaticamente todos os teus testes.

Quando termina de executar os seus testes, o Live Unit Testing mostra tanto os resultados globais como os resultados de testes individuais. Além disso, a janela do editor de código mostra graficamente tanto a cobertura do seu código de teste como o resultado dos seus testes. Como mostra a ilustração seguinte, os três testes foram executados com sucesso. Também mostra que os nossos testes cobriram todos os caminhos de código no StartsWithUpper método, e esses testes foram todos executados com sucesso (indicado pelo selo verde, "✓"). Finalmente, mostra que nenhum dos outros métodos na StringLibrary tem cobertura de código (indicada por uma linha azul, "➖").

O Explorador de Testes ao Vivo e a janela do editor de código após iniciar os testes de Unidade ao Vivo

Também pode obter informações mais detalhadas sobre a cobertura e os resultados dos testes selecionando um ícone específico de cobertura de código na janela do editor de código. Para examinar este detalhe, faça o seguinte:

Clique na marca de verificação verde na linha que diz if (String.IsNullOrWhiteSpace(s)) no método StartsWithUpper. Como mostra a ilustração seguinte, o Live Unit Testing indica que três testes cobrem essa linha de código, e que todos foram executados com sucesso.
Clique na marca de verificação verde na linha que lê return Char.IsUpper(s[0]) no método StartsWithUpper. Como mostra a ilustração seguinte, o Live Unit Testing indica que apenas dois testes cobrem essa linha de código, e que todos foram executados com sucesso.

O principal problema que o Live Unit Testing identifica é a cobertura incompleta do código. Vais abordar isso na secção seguinte.

Expandir a cobertura dos testes

Nesta secção, irá estender os seus testes unitários ao método StartsWithLower. Enquanto fazes isso, o Live Unit Testing continua a testar o teu código dinamicamente.

Para estender a cobertura do código ao StartsWithLower método, faça o seguinte:

Adicione os métodos TestStartsWithLower e TestDoesNotStartWithLower ao ficheiro de código-fonte de teste do seu projeto:

// Code to add to UnitTest1.cs
[TestMethod]
public void TestStartsWithLower()
{
    // Tests that we expect to return true.
    string[] words = { "alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство" };
    foreach (var word in words)
    {
        bool result = word.StartsWithLower();
        Assert.IsTrue(result,
                      $"Expected for '{word}': true; Actual: {result}");
    }
}

[TestMethod]
public void TestDoesNotStartWithLower()
{
    // Tests that we expect to return false.
    string[] words = { "Alphabet", "Zebra", "ABC", "Αθήνα", "Москва",
                       "1234", ".", ";", " "};
    foreach (var word in words)
    {
        bool result = word.StartsWithLower();
        Assert.IsFalse(result,
                       $"Expected for '{word}': false; Actual: {result}");
    }
}

Modifique o DirectCallWithNullOrEmpty método adicionando o código seguinte imediatamente após a chamada ao Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse método.

// Code to add to UnitTest1.cs
result = StringLibrary.StartsWithLower(word);
Assert.IsFalse(result,
               $"Expected for '{(word == null ? "<null>" : word)}': " +
               $"false; Actual: {result}");

O Live Unit Testing executa automaticamente novos e modificados testes quando modifica o seu código-fonte. Como mostra a ilustração seguinte, todos os testes, incluindo os dois que adicionou e o que modificou, tiveram sucesso.
Mude para a janela que contém o código-fonte da classe StringLibrary. O Live Unit Testing agora mostra que a nossa cobertura de código foi ampliada para cobrir o método StartsWithLower.

Em alguns casos, os testes bem-sucedidos no Test Explorer podem estar escancarados. Isso indica que um teste está atualmente a ser executado, ou que o teste não foi executado novamente porque não houve alterações no código que afetassem o teste desde a última execução.

Até agora, todos os nossos testes foram bem-sucedidos. Na secção seguinte, vamos analisar como pode lidar com falhas de teste.

Lidar com uma falha de teste

Nesta secção, irá explorar como pode usar o Live Unit Testing para identificar, resolver problemas e resolver falhas nos testes. Fará isso alargando a cobertura de testes ao método HasEmbeddedSpaces.

Adicione o seguinte método ao seu ficheiro de teste:

[TestMethod]
public void TestHasEmbeddedSpaces()
{
    // Tests that we expect to return true.
    string[] phrases = { "one car", "Name\u0009Description",
                         "Line1\nLine2", "Line3\u000ALine4",
                         "Line5\u000BLine6", "Line7\u000CLine8",
                         "Line0009\u000DLine10", "word1\u00A0word2" };
    foreach (var phrase in phrases)
    {
        bool result = phrase.HasEmbeddedSpaces();
        Assert.IsTrue(result,
                      $"Expected for '{phrase}': true; Actual: {result}");
    }
}

Quando o teste é executado, o Live Unit Testing indica que o TestHasEmbeddedSpaces método falhou, como mostra a ilustração seguinte:
Selecione a janela que mostra o código da biblioteca. O Live Unit Testing expandiu a cobertura do código para o método HasEmbeddedSpaces. Também reporta a falha do teste adicionando um "🞩" vermelho às linhas cobertas pelos testes falhados.
Passe o rato sobre a linha com a HasEmbeddedSpaces assinatura do método. O Live Unit Testing apresenta uma dica de ferramenta que informa que o método está coberto por um teste, como mostra a ilustração seguinte:
Selecione o teste falhado TestHasEmbeddedSpaces. O Live Unit Testing oferece-lhe algumas opções, como executar todos os testes e depurar todos os testes, como mostra a ilustração seguinte:
Selecione Debug All para depurar o teste falhado.
O Visual Studio executa o teste em modo de depuração.

O teste atribui cada string de um array a uma variável nomeada phrase e passa-a para o HasEmbeddedSpaces método. A execução do programa pausa e invoca o depurador na primeira vez que a expressão de afirmação é false. O diálogo de exceção que resulta do valor inesperado na chamada do método Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue é mostrado na seguinte ilustração.

Além disso, todas as ferramentas de depuração que o Visual Studio fornece estão disponíveis para nos ajudar a resolver o nosso teste falhado, como mostra a ilustração seguinte:

Note na janela Autos que o valor da phrase variável é "Name\tDescription", que é o segundo elemento do array. O método de teste espera HasEmbeddedSpaces devolver true quando passa esta cadeia; em vez disso, devolve false. Evidentemente, não reconhece "\t", o carácter tabulador, como espaço embutido.
Selecione Depurar>Continuar, pressione F5 ou clique no botão Continuar na barra de ferramentas para continuar a executar o programa de teste. Como ocorreu uma exceção não tratada, o teste termina. Isto fornece informação suficiente para uma investigação preliminar do bug. Ou TestHasEmbeddedSpaces (a rotina de teste) fez uma suposição incorreta, ou HasEmbeddedSpaces não reconhece corretamente todos os espaços embutidos.
Para diagnosticar e corrigir o problema, comece pelo StringLibrary.HasEmbeddedSpaces método. Veja a comparação no HasEmbeddedSpaces método. Considera um espaço embutido como U+0020. No entanto, o Padrão Unicode inclui vários outros caracteres de espaço. Isto sugere que o código da biblioteca foi testado incorretamente para um carácter de espaço em branco.
Substitua a comparação de igualdade por uma chamada ao System.Char.IsWhiteSpace método:
```
if (Char.IsWhiteSpace(ch))
```
O Live Unit Testing repete automaticamente o método de teste falhado.

O Live Unit Testing mostra os resultados atualizados, que aparecem também na janela do editor de código.