Configurar e usar o Live Unit Testing

Enquanto você desenvolve um aplicativo, o Live Unit Testing executa automaticamente todos os testes de unidade afetados em segundo plano e apresenta os resultados e a cobertura de código em tempo real. Quando você modifica seu código, o Live Unit Testing fornece comentários sobre como suas alterações afetaram os testes existentes e se o novo código adicionado é coberto por um ou mais testes existentes. Esses comentários lembram você de escrever testes de unidade à medida que você faz correções de bugs ou adiciona novos recursos.

Quando você usa o Live Unit Testing para seus testes, ele armazena dados sobre o status de seus testes. O uso de dados persistentes permite que o Live Unit Testing ofereça um desempenho superior ao executar seus testes dinamicamente 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 direcionados ao .NET Core ou ao .NET Framework.

Estruturas de teste com suporte

O Live Unit Testing funciona com as três estruturas de teste de unidade populares listadas na tabela a seguir. A versão mínima com suporte dos seus adaptadores e frameworks também é mostrada. As estruturas de teste de unidade estão todas disponíveis no NuGet.org.

Estrutura de teste	Versão mínima do adaptador do Visual Studio	Versão mínima da estrutura
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 você tiver projetos de teste baseados em MSTest mais antigos que fazem referência a Microsoft.VisualStudio.QualityTools.UnitTestFramework e não quiser migrar para os pacotes NuGet do MSTest mais recentes, atualize para o Visual Studio 2019 ou o Visual Studio 2017.

Em alguns casos, talvez seja necessário restaurar explicitamente os pacotes NuGet referenciados por um projeto para que o Live Unit Testing funcione. Você tem duas opções:

• Restaure fazendo um build explícito da solução. Selecione Compilar>Recompilar Solução no menu de nível superior do Visual Studio.
• Restaurar pacotes na solução. Clique com o botão direito do mouse na solução e selecione Restaurar Pacotes NuGet.

Configure

Na primeira vez que você inicia o Live Unit Testing para uma solução, um assistente de configuração permite que você configure a maneira como o Live Unit Testing deve criar e executar testes.

Quando o Live Unit Testing for interrompido, você também poderá abrir o assistente de instalação acessando Testar>Live Unit Testing>Configurar Live Unit Testing para a solução.

Quando o Live Unit Testing é executado, ele cria um workspace, que é uma cópia do repositório original. Em seguida, o Live Unit Testing aplica todas as alterações não salvas feitas no Visual Studio ao espaço de trabalho, realiza uma compilação, executa um teste e relata a cobertura de código atualizada.

A primeira coisa que você deve configurar usando o assistente é onde os arquivos 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 workspace do 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 arquivo de solução não está presente na raiz do repositório, a raiz do repositório pode precisar ser alterada.

Raiz do workspace

A raiz do workspace especifica a pasta em que o Live Unit Testing mantém um clone do repositório. Tenham atenção às exceções que indicam que o caminho é muito longo. Por padrão, a raiz é criada no diretório home do usuário. No entanto, como exemplo, se você normalmente precisar criar seu repositório na unidade C, a pasta raiz do workspace poderá ser ajustada para algo como C:\lut\Repo.

Especificar os arquivos excluídos

Nem todos os arquivos devem ser copiados para o workspace do Live Unit Testing. Todos os artefatos gerados durante a compilação devem ser excluídos da cópia para que as compilações regulares não interfiram nos builds do Live Unit Testing. Além disso, o comando regular nuget restore não deve interferir no comando Live Unit Testing nuget restore .

Por padrão, o Live Unit Testing exclui um dos dois padrões de arquivos:

• Para repositórios Git, os arquivos especificados no arquivo gitignore não são copiados para o workspace live unit testing.
• Para repositórios não Git, uma lista básica de pastas, como bin/ e obj/, não é copiada para o workspace do Live Unit Testing.

Para repositórios mais complexos, talvez seja necessário especificar seu próprio arquivo de ignorar. Selecione a opção "<Personalizado>" do assistente. Depois de selecionar Avançar, o conteúdo de um arquivo de exclusão personalizado criado pelo Live Unit Testing será exibido após a conclusão do assistente. É o arquivo lutignore .

Observação

Um arquivo lutignore personalizado é necessário para alguns repositórios Git porque é possível verificar arquivos no repositório Git que também são ignorados pelo arquivo gitignore . Sem um arquivo lutignore personalizado, o Live Unit Testing não copiará esses arquivos, o que pode levar a falhas de build.

Estrutura de arquivos do Lutignore

O arquivo lutignore usa o mesmo formato que um arquivo gitignore . Ele deve conter regras que correspondam às pastas ou arquivos gerados durante o build para que não sejam copiados para o workspace. Para a maioria dos templates padrão de projeto, o seguinte arquivo de exclusão é suficiente:

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

Se o repositório tiver uma única pasta de build, o arquivo ignore deverá listar essa pasta em vez disso:

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

Se o repositório incluir algumas outras ferramentas na pasta de build, essas ferramentas deverão ser excluídas no 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 build

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

• Gerar PDBs: Para acelerar a compilação, o Live Unit Testing não gera PDBs durante as compilações. Esses arquivos de símbolos permitem que você acesse os rastreamentos de pilha quando ocorrem falhas de teste.
• Compile usando vários núcleos de CPU: por padrão, o Live Unit Testing executa builds usando vários núcleos de CPU, o que melhora os tempos de build. Se o computador diminuir a velocidade ou se a solução não for criada usando vários processadores, não selecione essa opção.

Opções de execução de teste

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

• Tempo limite do caso de teste: alguns dos testes podem levar muito tempo para serem executados. A configuração desse campo anulará automaticamente as execuções se algum dos testes exceder uma duração de tempo específica. Os testes podem ser cancelados automaticamente.
• Use vários processadores: por padrão, o Live Unit Testing tenta usar vários processadores para acelerar o desempenho de execução. Se o computador diminuir a velocidade ou se a solução não puder executar testes em paralelo, não selecione essa opção. Por exemplo, esses cenários podem acontecer se vários testes tentarem gravar/ler nos mesmos caminhos de arquivo.

Mais configurações

Configure o Live Unit Testing selecionando Ferramentas>Opções na barra de menus superior do Visual Studio.

No painel Opções, expanda a seção Todas as Configurações>Teste>Teste de Unidade Dinâmico.

Depois que o Live Unit Testing estiver habilitado (consulte Iniciar, pausar e parar o Live Unit Testing), você poderá abrir as opções novamente selecionando Teste>Teste ao Vivo de Unidade>Opções.

As opções configuráveis incluem:

• Se o Live Unit Testing é pausado quando uma solução é criada e depurada.

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

• A capacidade de excluir todos os dados persistentes. Essa funcionalidade é útil quando o Live Unit Testing está se comportando de maneira imprevisível ou inesperada, o que sugere que os dados persistentes estão corrompidos.

• A quantidade máxima de memória que os processos do Live Unit Testing podem consumir.

• O nível de informações gravadas na janela Saída do Live Unit Testing.

  As opções incluem nenhum registro em log (Nenhum), somente mensagens de erro (Erro), mensagens de erro e mensagens informativas (Info, o padrão) ou todos os detalhes (Verbose).

  Você também pode exibir a saída detalhada na janela Saída do Live Unit Testing atribuindo o valor 1 a uma variável de ambiente de nível de usuário chamada VS_UTE_DIAGNOSTICS. Em seguida, reinicie o Visual Studio.

  Para capturar mensagens de log detalhadas do MSBuild do Live Unit Testing em um arquivo, defina a variável de ambiente no nível do usuário LiveUnitTesting_BuildLog para o nome do arquivo que conterá o log.

Personalizar seu build para o Live Unit Testing

Para soluções mais complexas, talvez seja necessário personalizar ainda mais o build. Por exemplo, talvez não seja necessário criar arquivos de tradução durante as execuções de teste. Para acelerar seus builds, você pode desabilitar o build de arquivo de tradução com o Live Unit Testing. Você pode fazer isso manipulando os arquivos do projeto.

Adicionar substituições para Live Unit Testing

Se sua solução exigir etapas personalizadas para compilar para instrumentação (Live Unit Testing) que não são necessárias para o build não instrumentado "regular", você pode adicionar código aos arquivos de projeto ou .targets que verificam a propriedade BuildingForLiveUnitTesting e executam etapas personalizadas de pré/pós-build.

Por exemplo, você pode escrever o exemplo a seguir para adicionar outro destino executado somente para o Live Unit Testing:

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

Você pode usar a BuildingForLiveUnitTesting propriedade para desabilitar algumas tarefas que não devem ser executadas para builds de teste. Por exemplo, o Live Unit Testing define <RunAnalyzers>false</RunAnalyzers> para desabilitar analisadores para testes.

Dependências de teste do Live Unit Testing

É possível que nem todos os arquivos tenham sido copiados necessários para que os testes sejam executados. O Live Unit Testing cria uma pasta separada em que executa testes. Essa disposição permite que os builds ocorram enquanto os testes estão em execução, mas nem todos os arquivos da pasta de build são copiados para a pasta de teste.

Normalmente, você adiciona as dependências de teste por um dos dois motivos:

• Seus testes dependem de arquivos na estrutura de diretórios de origem. Por exemplo, os testes examinam o conteúdo dos arquivos resx ou talvez leem alguns arquivos de configuração.
• Seus testes dependem de algumas bibliotecas que eles fazem referência. Por exemplo, um teste executa um executável criado como uma dependência.

Observação

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

Em ambos os casos, o Live Unit Testing por padrão não copiará esses arquivos com a finalidade de minimizar o número de arquivos que precisam ser copiados para executar um teste. Você precisa especificar explicitamente esses arquivos usando a LiveUnitTestingTestDependency propriedade se eles forem necessários para uma execução de teste. Por exemplo, digamos que temos o seguinte layout:

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

Por padrão, quando você cria esses projetos com o Live Unit Testing, ele copia Artifacts/Test_Project apenas para a pasta de teste. Para adicionar fontes ou o 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 habilitar o Live Unit Testing, selecione Test>Live Unit Testing>Start no menu de nível superior do Visual Studio. Quando o Live Unit Testing está habilitado, as opções disponíveis no menu Live Unit Testing mudam de um único item, Iniciar, para Pausar e Parar:

• Pausar suspende temporariamente o Live Unit Testing.

  Quando o Live Unit Testing é pausado, a visualização de cobertura não aparece no editor, mas todos os dados coletados são preservados. Para retomar o Live Unit Testing, selecione Continuar no menu Live Unit Testing . O Live Unit Testing faz o trabalho necessário para acompanhar todas as edições que foram feitas durante a pausa e atualiza os glifos adequadamente.

• Interrompa completamente o Live Unit Testing. O Live Unit Testing descarta todos os dados coletados.

Se você iniciar o Live Unit Testing em uma solução que não inclua um projeto de teste de unidade, as opções Pausar e Parar aparecerão no menu Live Unit Testing , mas o Live Unit Testing não será iniciado. A janela Saída exibe uma mensagem que começa: "Nenhum adaptador de teste com suporte é referenciado por essa solução...".

A qualquer momento, você pode pausar temporariamente ou parar completamente o Live Unit Testing. Talvez você queira executar essas ações, por exemplo, se estiver no meio da refatoração e souber que seus testes serão interrompidos por um tempo.

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

Quando você inicia o Live Unit Testing, a janela da ferramenta Live Unit Testing é exibida e solicita que você selecione o conjunto de testes que você deseja testar pelo Live Unit Testing.

Para soluções menores em que os testes de unidade levam muito pouco tempo para serem 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, você pode controlar quais projetos e métodos individuais em um projeto participam do Live Unit Testing editando a playlist. Por exemplo, se você tiver uma solução com centenas de projetos de teste, poderá selecionar um conjunto direcionado de projetos de teste para participar do Live Unit Testing.

Você escolhe quais testes o Live Unit Testing deve executar editando uma playlist do Live Unit Testing, um recurso que funciona exatamente como playlists no Gerenciador de Testes.

Há várias maneiras de editar a playlist do Live Unit Testing:

• Janela de ferramentas do Live Unit Testing
• A janela do editor de código
• Gerenciador de Soluções
• Programaticamente em código de teste

O Live Unit Testing salva o estado de inclusão/exclusão como uma configuração de usuário e lembra quando uma solução é fechada e reaberta.

Janela de ferramentas do Live Unit Testing

Você pode usar o editor de playlist da guia Live Unit Testing para incluir ou excluir projetos, namespaces ou classes da execução. Selecione Editar playlist na janela da ferramenta.

Você pode selecionar ou limpar os elementos de exibição de árvore para incluir ou excluir testes. Por exemplo, se você verificar um único teste, o Live Unit Testing o executará quando houver alterações. Se você selecionar uma classe, todos os testes nessa classe serão executados e todos os novos testes adicionados a essa classe também serão executados.

A janela do editor de código

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

• Live Unit Testing>Incluir <método> selecionado
• Live Unit Testing>Excluir <método> selecionado
• Live Unit Testing>Excluir tudo <exceto o método> selecionado

Gerenciador de Soluções

Para selecionar os projetos individuais em testes de unidade, siga estas etapas depois que o Live Unit Testing for iniciado:

1. Clique com o botão direito do mouse na solução no Gerenciador de Soluções e selecione Live Unit Testing>Exclude para excluir toda a solução.
2. Clique com o botão direito do mouse em cada projeto de teste que você deseja incluir nos testes e selecione Live Unit Testing>Include.

Programaticamente em código de teste

Você pode aplicar o ExcludeFromCodeCoverageAttribute atributo para excluir programaticamente métodos, classes ou estruturas de relatar sua cobertura no Live Unit Testing.

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

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

Use os seguintes atributos para excluir um assembly de testes inteiro do Live Unit Testing.

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

Visualizar a cobertura

Depois que o Live Unit Testing estiver habilitado, ele atualizará cada linha de código no editor do Visual Studio para mostrar se o código que você está escrevendo é coberto por testes de unidade e se os testes que o abrangem estão passando.

A imagem a seguir mostra linhas de código com testes aprovados e com falha e linhas de código que não são cobertas por testes. As linhas com um "✓" verde são cobertas apenas por testes bem-sucedidos. Linhas com um "x" vermelho indicam um ou mais testes com falha. As linhas com um "➖" azul não são cobertas por nenhum teste.

A visualização de cobertura do Live Unit Testing é atualizada imediatamente quando você modifica o código no editor de código. Ao processar as edições, a visualização muda para indicar que os dados não estão atualizados ao adicionar uma imagem de cronômetro redondo abaixo dos símbolos de passado, falha e não coberto, como mostra a imagem a seguir.

Obter informações sobre o status do teste

Ao passar o mouse sobre o símbolo passado ou com falha na janela de código, você pode ver quantos testes estão atingindo essa linha. Para ver o status dos testes individuais, selecione o símbolo.

Além de fornecer os nomes e os resultados dos testes, a dica de ferramenta permite executar novamente ou depurar o conjunto dos testes. Se você selecionar um ou mais testes no tooltip, poderá também executar ou depurar somente esses testes. Essa ação permite que você depure seus testes sem precisar sair da janela de código.

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

Quando você passa o mouse sobre um teste com falha no tooltip, ele se expande para fornecer mais informações sobre a falha, conforme mostrado na imagem a seguir. Para acessar diretamente um teste com falha, dê um duplo clique sobre ele no tooltip.

Ao acessar um teste com falha, o Live Unit Testing indica visualmente na assinatura do método os testes que têm:

• Passado (indicado por um béquer meio cheio junto com um '✓' verde).
• Falha (indicado por um béquer meio cheio junto com um "🞩" vermelho).
• Não estão envolvidos no Live Unit Testing (indicado por um béquer meio cheio juntamente com um "➖").

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

Diagnosticar e corrigir falhas de teste

No teste com falha, você pode depurar facilmente o código do produto, fazer edições e continuar desenvolvendo seu aplicativo. Como o Live Unit Testing é executado em segundo plano, você não precisa parar e reiniciar o Live Unit Testing durante o ciclo de depuração, edição e continuação.

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

Janela Live Unit Testing

O Live Unit Testing, semelhante ao Gerenciador de Testes, fornece uma interface que permite executar e depurar testes e analisar resultados de teste. Quando o Live Unit Testing está habilitado, o status dos testes de unidade no Gerenciador de Testes é atualizado imediatamente. Você não precisa executar explicitamente os testes de unidade.

Quando o Live Unit Testing não está habilitado ou é interrompido, o Live Unit Testing exibe o status dos testes de unidade na última vez em que um teste foi executado. Depois de reiniciar o Live Unit Testing, uma alteração de código-fonte é necessária para executar novamente os testes.

Você pode iniciar o Live Unit Testing selecionando Test>Live Unit Testing>Start no menu de nível superior do Visual Studio. Você também pode abrir a janela Live Unit Testing usando Exibir>Outras Janelas>Janela de Live Unit Testing.

Você pode observar na janela Live Unit Testing que alguns testes estão desbotados. Por exemplo, quando você para e reinicia o Live Unit Testing, a janela Live Unit Testing esmaece todos os testes, como mostra a imagem a seguir.

Os resultados de teste esmaecidos indicam que o teste não fazia parte da última execução do Live Unit Test. Os testes só são executados quando uma alteração no teste ou nas dependências do teste é detectada. Se não houver nenhuma alteração, ele evitará executar o teste desnecessariamente. Nesse caso, o resultado do teste desativado continua atualizado, embora não tenha feito parte do último processo.

Você pode executar novamente qualquer teste que apareça desbotado fazendo uma alteração no código.

Há algumas diferenças entre o Live Unit Testing executando e atualizando automaticamente os resultados do teste e executando testes explicitamente do Gerenciador de Testes. Essas diferenças incluem:

• A execução ou a depuração de testes na janela do Gerenciador de Testes executa binários regulares. O Live Unit Testing executa binários instrumentados.
• O Live Unit Testing não cria um novo domínio de aplicativo para executar testes. Em vez disso, ele executa testes do domínio padrão. Os testes executados na janela do Gerenciador de Testes criam um novo domínio de aplicativo.
• Live Unit Testing executa testes em cada assembly de teste de forma sequencial. Na janela do Gerenciador de Testes , você pode optar por executar vários testes em paralelo.

Cancelar execuções de teste do Live Unit Testing

O Live Unit Testing continua executando testes sempre que você faz alterações de código. Se uma execução estiver em andamento e você fizer mais alterações de código, o Live Unit Testing enfileira outra execução enquanto aguarda a primeira execução ser concluída.

Sempre que você salva arquivos, o Live Unit Testing cancela a primeira execução e agenda imediatamente a execução na fila. Esse processo ajuda com cenários em que a primeira execução levaria muito tempo para ser concluída.

Consulte também

• Ferramentas de teste de código
• Blog do Live Unit Testing
• Perguntas frequentes sobre o Live Unit Testing