Configurar e utilizar o Live Unit Testing

Enquanto desenvolves uma aplicação, o Live Unit Testing executa automaticamente quaisquer testes unitários afetados em segundo plano e apresenta os resultados e a cobertura do código em tempo real. Quando modifica o seu código, o Live Unit Testing fornece feedback sobre como as suas alterações afetaram os testes existentes e se o novo código que adicionou está coberto por um ou mais testes existentes. Este feedback lembra-te de escrever testes unitários à medida que corriges bugs ou adicionas novas funcionalidades.

Quando utiliza o Live Unit Testing para os seus testes, regista dados sobre o estado dos seus testes. A utilização de dados persistentes permite que os Testes Unitários ao Vivo ofereçam desempenho superior enquanto executam os seus testes de forma dinâmica em resposta a alterações de código.

O Live Unit Testing está disponível apenas na edição Enterprise do Visual Studio para projetos que visam .NET Core ou .NET Framework.

Frameworks de teste suportados

O Live Unit Testing funciona com os três frameworks populares de testes unitários listados na tabela seguinte. Também é mostrada a versão mínima suportada dos seus adaptadores e frameworks. Os frameworks de testes unitários estão todos disponíveis pela NuGet.org.

Estrutura de teste	Versão mínima do adaptador Visual Studio	Versão mínima do framework
xUnit.net	xunit.runner.visualstudio versão 2.2.0-beta3-build1187	xunit 1.9.2
NUnit	NUnit3TestAdapter versão 3.5.1	NUnit versão 3.5.0
MSTest	MSTest.TestAdapter 1.1.4-preview	MSTest.TestFramework 1.0.5-preview

Se tem projetos de teste antigos baseados em MSTest que fazem referência ao Microsoft.VisualStudio.QualityTools.UnitTestFramework, e não quiser migrar para os pacotes mais recentes do MSTest NuGet, atualize para o Visual Studio 2019 ou Visual Studio 2017.

Em alguns casos, pode ser necessário restaurar explicitamente os pacotes NuGet referenciados por um projeto para que o Live Unit Testing funcione. Tem duas opções:

• Restaura realizando uma compilação explícita da solução. Selecione Build>Rebuild Solution no menu principal do Visual Studio.
• Restaurar pacotes na solução. Clique com o botão direito na solução e selecione Restaurar Pacotes NuGet.

Configure

Na primeira vez que inicias o Live Unit Testing para uma solução, um assistente de configuração permite-te configurar a forma como o Live Unit Testing deve compilar e executar testes.

Quando o Live Unit Testing está parado, também pode abrir o assistente de configuração acessando Testar>Live Unit Testing>Configurar Live Unit Testing para a solução.

Quando o Live Unit Testing é executado, cria-se um espaço de trabalho, que é uma cópia do repositório original. O Live Unit Testing aplica então quaisquer alterações não guardadas que tenha feito no Visual Studio ao espaço de trabalho, realiza uma compilação, faz um teste e reporta a cobertura mais recente do código.

A primeira coisa que deve configurar usando o assistente é de onde os ficheiros devem ser copiados e para onde devem ser copiados.

Raiz do repositório

A raiz do repositório especifica a pasta que será copiada para criar o espaço de trabalho Live Unit Testing. Deve ser a pasta raiz do repositório, ou seja, deve conter todas as fontes, binários e ferramentas. Nos casos em que o ficheiro de solução não está presente na raiz do repositório, a raiz do repositório pode ter de ser alterada.

Raiz do espaço de trabalho

A raiz do workspace especifica a pasta onde o Live Unit Testing mantém um clone do repositório. Cuidado com exceções que indiquem que o caminho é demasiado longo. Por defeito, a raiz é criada na tua pasta principal. No entanto, por exemplo, se normalmente precisares de criar o teu repositório na unidade C, a raiz do workspace pode ser ajustada para algo como C:\lut\Repo.

Especifique os ficheiros excluídos

Nem todos os ficheiros devem ser copiados para o espaço de trabalho de Testes Unitários ao Vivo. Quaisquer artefactos gerados durante a build devem ser excluídos da cópia para que as builds normais não interfiram com as builds de Live Unit Testing. Além disso, o comando normal nuget restore não deve interferir com o comando Live Unit Testing nuget restore .

Por defeito, o Live Unit Testing exclui um dos dois padrões de ficheiros:

• Para repositórios Git, os ficheiros especificados no ficheiro gitignore não são copiados para o espaço de trabalho Live Unit Testing.
• Para repositórios que não são Git, uma lista básica de pastas, como bin/ e obj/, não é copiada para o espaço de trabalho Live Unit Testing.

Para repositórios mais complexos, pode ser necessário especificar seu próprio ficheiro de ignorar. Selecione a opção "<Personalizado>" no assistente. Depois de selecionar Seguinte, aparece o conteúdo de um ficheiro de exclusão personalizado que o Live Unit Testing cria depois de terminar o assistente. É o ficheiro Lutignore .

Observação

Um ficheiro lutignore personalizado é necessário para alguns repositórios Git porque é possível inserir ficheiros no repositório Git que também são ignorados pelo gitignore. Sem um ficheiro lutignore personalizado, o Live Unit Testing não copia estes ficheiros, o que pode levar a falhas na compilação.

Estrutura de ficheiros Lutignore

O ficheiro lutignore usa o mesmo formato que um ficheiro gitignore . Deve conter regras que correspondam às pastas ou ficheiros gerados durante a compilação, para que não sejam copiados para o espaço de trabalho. Para a maioria dos modelos de projeto padrão, o seguinte ficheiro de ignorar é suficiente:

[Bb]in
[Oo]bj
# WILL NOT COPY ANY BIN AND OBJ FOLDERS TO THE LIVE UNIT TESTING WORKSPACE

Se o teu repositório tiver uma única pasta de build, o ficheiro ignore deve listar essa pasta em vez disso:

[Aa]rtifacts/
# WILL NOT COPY THE ARTIFACTS FOLDER TO THE LIVE UNIT TESTING WORKSPACE

Se o seu repositório incluir outras ferramentas na pasta de compilação, essas ferramentas devem ser excluídas do conjunto de padrões correspondentes:

[Aa]rtifacts/
![Aa]rtifacts/tools/
# WILL NOT COPY THE ARTIFACTS FOLDER TO THE LIVE UNIT TESTING WORKSPACE
# HOWEVER IT WILL COPY THE TOOLS SUBFOLDER THAT MIGHT CONTAIN TOOLS AND UTILITIES

Opções de construção

A segunda parte da página de configuração do assistente é onde configuras as opções de build:

• Gerar PDBs: Para acelerar a compilação, o Live Unit Testing não gera PDBs durante as compilações. Estes ficheiros de símbolos permitem-lhe aceder aos traços da pilha quando ocorrerem falhas nos testes.
• Construir usando múltiplos núcleos de CPU: Por defeito, o Live Unit Testing realiza compilações usando múltiplos núcleos de CPU, o que melhora os tempos de compilação. Se a sua máquina abrandar ou se a sua solução não for construída usando vários processadores, não selecione esta opção.

Opções de teste

A última parte da página de configuração do assistente é onde configuras as opções de teste de execução:

• Tempo limite do caso de teste: Alguns dos testes podem demorar muito tempo para serem executados. Definir este campo aborta automaticamente as execuções se algum dos testes exceder uma duração de tempo específica. Os testes podem ser cancelados automaticamente.
• Use múltiplos processadores: Por defeito, o Live Unit Testing tenta usar vários processadores para acelerar o desempenho da execução. Se a sua máquina abrandar ou se a sua solução não conseguir fazer testes em paralelo, não selecione esta opção. Por exemplo, estes cenários podem acontecer se vários testes tentarem escrever/ler a partir dos mesmos caminhos de ficheiros.

Mais opções de configuração

Configure Testes Unitários ao Vivo selecionando Ferramentas>Opções na barra de menu principal do Visual Studio.

No painel de Opções, expanda a secção Todas as Configurações>Teste>Testes Unitários ao Vivo.

Depois de o Live Unit Testing estar ativado (ver Iniciar, pausar e parar Live Unit Testing), pode abrir novamente as opções selecionando Testar>Live Unit Testing>Opções.

As opções configuráveis incluem:

• Se o Live Unit Testing é suspenso quando uma solução é compilada e depurada.

• Se o Live Unit Testing pausa quando a energia da bateria de um sistema fica abaixo de um limiar especificado.

• A capacidade de apagar todos os dados persistentes. Esta capacidade é útil quando o Live Unit Testing se comporta de forma imprevisível ou inesperada, o que sugere que os dados persistentes estão corrompidos.

• A quantidade máxima de memória que os processos de Testes Unitários ao Vivo conseguem consumir.

• O nível de informação escrita na janela de Saída do Teste Unitário em Tempo Real.

  As opções incluem sem registo (Nenhum), apenas mensagens de erro (Erro), mensagens de erro e informativas (Info, o padrão), ou todos os detalhes (Verbose).

  Também pode mostrar uma saída detalhada na janela de Saída de Testes Unitários ao Vivo, atribuindo um valor 1 a uma variável de ambiente ao nível do utilizador chamada VS_UTE_DIAGNOSTICS. Depois reinicia o Visual Studio.

  Para capturar mensagens detalhadas de log do MSBuild do Live Unit Testing num ficheiro, defina a LiveUnitTesting_BuildLog variável de ambiente de nível de utilizador para o nome do ficheiro que irá conter o log.

Personaliza a tua build para Testes Unitários ao Vivo

Para soluções mais complexas, pode ser necessário personalizar ainda mais a construção. Por exemplo, pode não ser necessário construir ficheiros de tradução durante os testes. Para acelerar as tuas builds, podes desativar a build do ficheiro de tradução com Live Unit Testing. Podes fazer isso manipulando os ficheiros do projeto.

Adicionar exceções de Live Unit Testing

Se a tua solução exigir etapas personalizadas para construir para instrumentação (Live Unit Testing) que não são exigidas para a compilação "normal" não instrumentada, podes adicionar código ao teu projeto ou ficheiros .targets que verifiquem a BuildingForLiveUnitTesting propriedade e realizem etapas personalizadas antes/depois da compilação.

Por exemplo, pode escrever o seguinte exemplo para adicionar outro alvo executado apenas para Testes Unitários ao Vivo:

<Target Name="GenerateNuGetPackages" BeforeTargets="AfterBuild" Condition="'$(BuildingForLiveUnitTesting)' == 'true'">
    <Exec Command='"$(MSBuildThisFileDirectory)..\tools\GenPac" '/>
</Target>

Podes usar a BuildingForLiveUnitTesting propriedade para desativar algumas tarefas que não deveriam ser executadas em compilações de teste. Por exemplo, o Live Unit Testing configura <RunAnalyzers>false</RunAnalyzers> para desativar analisadores para testes.

Dependências dos Testes Unitários em Tempo Real

É possível que nem todos os ficheiros necessários para os testes funcionarem foram copiados. O Live Unit Testing cria uma pasta separada onde executa os testes. Esse arranjo permite que builds ocorram enquanto os testes estão a correr, mas nem todos os ficheiros da pasta de build são copiados para a pasta de teste.

Normalmente, adicionam-se as dependências de teste por um dos dois motivos:

• Os teus testes dependem de ficheiros na árvore de origem. Por exemplo, os testes examinam o conteúdo dos ficheiros resx ou talvez leiam alguns ficheiros de configuração.
• Os teus testes dependem de algumas bibliotecas às quais fazem referência. Por exemplo, um teste executa um executável construído como uma dependência.

Observação

As dependências de teste devem existir dentro do diretório especificado como Raiz do Repositório no assistente de configuração.

Em ambos os casos, o Live Unit Testing, por defeito, não copia estes ficheiros para minimizar o número de ficheiros que têm de ser copiados para executar um teste. Tens de especificar explicitamente estes ficheiros usando a LiveUnitTestingTestDependency propriedade se forem necessários para um teste. Por exemplo, imaginemos que temos o seguinte layout:

SRC/
  CONSOLE_UTILITY/
  TEST_PROJECT/
ARTIFACTS/
  CONSOLE_UTILITY/NET472/DEBUG/
  TEST_PROJECT/NET472/DEBUG/

Por padrão, quando constróis estes projetos com Live Unit Testing, só copia Artifacts/Test_Project para a pasta de teste. Para adicionar fontes ou a console_utility à pasta de teste, adicione o seguinte exemplo a:test_project.csproj

<LiveUnitTestingTestDependency Include=”$(RepoRoot)/Src/ConsoleUtility” />
<LiveUnitTestingTestDependency Include=”$(RepoRoot)/Artifacts/ConsoleUtility/net472/$(Configuration)/</LiveUnitTestingTestDependency” />

Iniciar, pausar e parar

Para ativar o Live Unit Testing, selecione Test>Live Unit>Testing Start no menu principal do Visual Studio. Quando o Live Unit Testing está ativado, as opções disponíveis no menu Live Unit Testing mudam de um único item, Iniciar, para Pausar e Parar:

• A pausa suspende temporariamente o Teste Unitário ao Vivo.

  Quando o Live Unit Testing está pausado, a visualização da cobertura não aparece no editor, mas todos os dados recolhidos são preservados. Para retomar os Testes Unitários ao Vivo, selecione Continuar no menu de Testes Unitários ao Vivo . O Live Unit Testing faz o trabalho necessário para acompanhar todas as edições feitas durante a pausa e atualiza os glifos de forma adequada.

• Stop para completamente o Live Unit Testing. O Live Unit Testing descarta todos os dados que recolheu.

Se iniciar o Live Unit Testing numa solução que não inclua um projeto de teste unitário, as opções Pausar e Parar aparecem no menu Live Unit Testing , mas o Live Unit Testing não começa. A janela de Saída apresenta uma mensagem que começa: "Nenhum adaptador de teste suportado é referenciado por esta solução...".

A qualquer momento, pode pausar temporariamente ou parar completamente o Live Unit Testing. Podes querer tomar estas ações, por exemplo, se estiveres a meio de uma refatoração e souberes que os teus testes vão falhar durante algum tempo.

Incluir e excluir projetos de teste e métodos de teste

Quando inicia o Live Unit Testing, a janela da ferramenta Live Unit Testing aparece e pede-lhe para selecionar o conjunto de testes que pretende testar pelo Live Unit Testing.

Para soluções mais pequenas onde os testes unitários demoram muito pouco tempo a ser executados, selecione Incluir todos os testes, o que faz com que o Live Unit Testing execute todos os testes.

Para soluções maiores com muitos projetos de teste, pode controlar quais os projetos e métodos individuais de um projeto que participam no Live Unit Testing editando a playlist. Por exemplo, se tiver uma solução com centenas de projetos de teste, pode selecionar um conjunto direcionado de projetos de teste para participar no Live Unit Testing.

Escolhe que Testes Unitários ao Vivo deve executar editando uma playlist de Testes Unitários ao Vivo, uma funcionalidade que funciona tal como as playlists no Explorador de Testes.

Existem várias formas de editar a playlist Live Unit Testing:

• Janela da ferramenta Live Unit Testing
• A janela do editor de código
• Explorador de Soluções
• Programáticamente em código de teste

O Live Unit Testing guarda o estado de inclusão/exclusão como uma definição de utilizador e lembra-se dele quando uma solução é fechada e reaberta.

Janela da ferramenta de Testes Unitários em Tempo Real

Pode usar o editor de playlists do separador Live Unit Testing para incluir ou excluir projetos, namespaces ou classes da execução. Selecione Editar lista de reprodução na janela da ferramenta.

Pode selecionar ou limpar os elementos da vista em árvore para incluir ou excluir testes. Por exemplo, se verificar um teste único, o Live Unit Testing executa-o quando ocorrem alterações. Se selecionares uma classe, todos os testes dessa classe são executados e quaisquer novos testes adicionados a essa classe também correm.

A janela do editor de código

Pode usar a janela do editor de código para incluir ou excluir métodos de teste individuais. Clique com o botão direito na assinatura ou corpo do método de teste na janela do editor de código e selecione uma das seguintes opções:

• Testes Unitários ao Vivo>Incluir <método> selecionado
• Testes Unitários ao Vivo>Excluir <método> selecionado
• Testes Unitários ao Vivo>Excluir Todos Exceto <método selecionado>

Explorador de Soluções

Para selecionar os projetos individuais nos testes unitários, siga estes passos após o início do Live Unit Testing:

1. Clique com o botão direito na solução no Explorador de Soluções e selecione Testes Unitários ao Vivo>Excluir para excluir toda a solução.
2. Clique com o botão direito em cada projeto de teste que pretende incluir nos testes e selecione Testes Unitários ao Vivo>Incluir.

Programáticamente em código de teste

Pode aplicar o ExcludeFromCodeCoverageAttribute atributo para excluir programaticamente métodos, classes ou estruturas de reportar a sua cobertura em Live Unit Testing.

Use os seguintes atributos para excluir métodos individuais do Live Unit Testing:

• xUnidade: [Trait("Category", "SkipWhenLiveUnitTesting")]
• NUnit: [Category("SkipWhenLiveUnitTesting")]
• MSTest: [TestCategory("SkipWhenLiveUnitTesting")]

Use os seguintes atributos para excluir um conjunto inteiro de testes do Live Unit Testing:

• xUnidade: [assembly: AssemblyTrait("Category", "SkipWhenLiveUnitTesting")]
• NUnit: [assembly: Category("SkipWhenLiveUnitTesting")]
• MSTest: [assembly: TestCategory("SkipWhenLiveUnitTesting")]

Visualizar a cobertura

Depois de o Live Unit Testing estar ativado, atualiza cada linha de código no editor Visual Studio para te mostrar se o código que estás a escrever está coberto por testes unitários e se os testes que o cobrem estão a passar.

A imagem seguinte mostra linhas de código com testes de aprovação e reprovação, e linhas de código que não são cobertas pelos testes. Linhas com um "✓" verde são cobertas apenas por testes de aprovação. As linhas com um "x" vermelho são cobertas por um ou mais testes que falham. Linhas com um "➖" azul não são cobertas por nenhum teste.

A visualização da cobertura do Live Unit Testing é atualizada imediatamente quando modifica o código no editor de código. Durante o processamento das edições, a visualização muda para indicar que os dados não estão atualizados, adicionando uma imagem de temporizador circular por baixo dos símbolos de aprovação, reprovação e não cobertura, como mostra a imagem seguinte.

Obtenha informações sobre o estado do teste

Ao passar o rato sobre o símbolo de passado ou falhado na janela de código, pode ver quantos testes estão a atingir essa linha. Para ver o estado dos testes individuais, selecione o símbolo.

Além de fornecer os nomes e resultados dos testes, a dica permite executar novamente ou depurar o conjunto de testes. Se selecionares um ou mais dos testes na tooltip, também podes correr ou depurar apenas esses testes. Esta ação permite-lhe depurar os seus testes sem ter de sair da janela de código.

Quando está a depurar, além de observar quaisquer pontos de interrupção que já tenha definido, a execução do programa pausa quando o depurador executa um Assert método que devolve um resultado inesperado.

Quando passa o cursor sobre um teste falhado no tooltip, expande-se para fornecer mais informações sobre o erro, como mostrado na imagem seguinte. Para ir diretamente a um teste falhado, dê um duplo clique no tooltip.

Quando vai ao teste falhado, o Live Unit Testing indica visualmente na assinatura do método os testes que têm:

• Aprovado (indicado por um béquer meio cheio acompanhado de um "✓" verde).
• Falhou (indicado por um béquer meio cheio acompanhado de um "🞩" vermelho).
• Não estão envolvidos em Testes Unitários ao Vivo (indicado por um béquer meio cheio juntamente com um "➖" azul).

Métodos não-testes não são identificados com um símbolo. A imagem seguinte ilustra os quatro tipos de métodos.

Diagnosticar e corrigir falhas nos testes

A partir do teste falhado, pode facilmente depurar o código do produto, fazer edições e continuar a desenvolver a sua aplicação. Como o Live Unit Testing corre em segundo plano, não precisa de parar e reiniciar o Live Unit Testing durante o ciclo de depuração, edição e continuação.

Por exemplo, a falha do teste mostrada na imagem anterior foi causada por uma suposição incorreta no método de teste de que caracteres não alfabéticos retornam true quando passados para o System.Char.IsLower método. Depois de corrigires o método de teste, todos os testes devem passar. Não tens de pausar ou parar o Live Unit Testing.

Janela de Testes Unitários ao Vivo

O Live Unit Testing, semelhante ao Test Explorer, fornece uma interface que permite executar e depurar testes e analisar resultados de testes. Quando o Live Unit Testing está ativado, o estado dos testes unitários no Test Explorer é atualizado imediatamente. Não precisas de executar explicitamente os testes unitários.

Quando o Live Unit Testing não está ativado ou é interrompido, o Live Unit Testing mostra o estado dos testes unitários da última vez que um teste foi executado. Depois de reiniciar o Live Unit Testing, é necessária uma alteração no código-fonte para reexecutar os testes.

Pode iniciar o Teste Unitário ao Vivo selecionando Testar>Teste Unitário ao Vivo>Iniciar no menu superior do Visual Studio. Também pode abrir a janela Testes Unitários ao Vivo usando Ver>Outras Janelas>Janela de Testes Unitários ao Vivo.

Pode reparar na janela de Testes Unitários ao Vivo que alguns testes estão desvanecidos. Por exemplo, quando se para e reinicia o Live Unit Testing, a janela de Live Unit Testing desvanece todos os testes, como mostra a imagem seguinte.

Resultados de testes desbotados indicam que o teste não fazia parte da mais recente execução do Live Unit Test. Os testes só são executados quando é detetada uma alteração no teste ou nas dependências do teste. Se não houver alterações, evita a execução desnecessária do teste. Neste caso, o resultado do teste esvaziado ainda está "atualizado", embora não tenha feito parte da última análise.

Pode refazer quaisquer testes que pareçam esmaecidos, fazendo uma alteração de código.

Existem algumas diferenças entre o Live Unit Testing, que executa e atualiza automaticamente os resultados dos testes e executa explicitamente testes a partir do Test Explorer. Estas diferenças incluem:

• Executar ou depurar testes a partir da janela do Explorador de Testes executa binários normais. Testes Unitários ao Vivo executam binários instrumentados.
• O Live Unit Testing não cria um novo domínio de aplicação para executar testes. Em vez disso, executa testes a partir do domínio predefinido. Os testes executados a partir da janela do Explorador de Testes criam um novo domínio de aplicação.
• O Live Unit Testing executa testes em cada conjunto de testes sequencialmente. Na janela do Explorador de Testes , pode escolher executar múltiplos testes em paralelo.

Cancelar testes de Testes Unitários ao Vivo

O Live Unit Testing continua a executar testes sempre que fazes alterações de código. Se uma execução estiver em curso e fizer mais alterações ao código, o Live Unit Testing enfileira outra execução enquanto aguarda a conclusão da primeira execução.

Sempre que guardas ficheiros, o Live Unit Testing cancela a primeira execução e agenda imediatamente a execução em fila. Este processo ajuda em cenários em que a primeira tentativa teria demorado muito tempo a ser concluída.

Consulte também

• Ferramentas de teste de código
• Blogue de Testes Unitários ao Vivo
• Perguntas Frequentes sobre Testes Unitários ao Vivo