Como configurar e usar o Live Unit Testing

Artigo
08/22/2023

Durante o desenvolvimento de um aplicativo, o Live Unit Testing executa automaticamente testes de unidades afetadas em segundo plano e apresenta os resultados e a cobertura de código em tempo real. Durante a modificação do código, o Live Unit Testing fornece comentários sobre como as alterações afetaram os testes existentes e se o novo código adicionado é abrangido 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ê utilizar o Live Unit Testing para seus testes, ele preservará os dados sobre o status dos seus testes. Utilizar dados persistentes permite que o Live Unit Testing ofereça desempenho superior ao executar seus testes de forma dinâmica em resposta a mudanças 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 o .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 de seus adaptadores e suas estruturas também mostrada. As estruturas de teste de unidade estão disponíveis em 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 mais antigos baseados no MSTest que referenciam Microsoft.VisualStudio.QualityTools.UnitTestFramework e não quiser migrar para os pacotes NuGet mais recentes do MSTest, atualize para o Visual Studio 2019 ou 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 uma compilação explícita 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 na solução e selecione Restaurar Pacotes NuGet.

Configurar

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 configuração acessando Teste>Live Unit Testing>Configurar o Live Unit Testing para 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 workspace, executa um build, faz uma execução de teste e relata a cobertura de código mais recente.

A primeira coisa que você deve configurar usando o assistente é onde os arquivos devem ser copiados e para onde devem ser copiados.

Captura de tela que mostra a página 1 do assistente de configuração do Live Unit Testing.

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 esteja presente na raiz do repositório, talvez a raiz do repositório precise 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. Cuidado com exceções que indicam que o caminho é muito longo. Por padrão, a raiz é criada na pasta inicial. No entanto, como exemplo, se você normalmente precisa criar seu repositório na unidade C, a 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 nas compilações do Live Unit Testing. Além disso, o comando nuget restore regular não deve interferir no comando nuget restoredo Live Unit Testing.

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 do 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>" no assistente. Depois de selecionar Próximo, o conteúdo de um arquivo de ignorar personalizado criado pelo Live Unit Testing após a conclusão do assistente será exibido. É 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 compilação.

Estrutura de arquivos do Lutignore

O arquivo lutignore usa o mesmo formato de um arquivo gitignore. Ele deve conter regras que correspondam às pastas ou arquivos gerados durante a compilação para que não sejam copiados para o workspace. Para a maioria dos modelos de projeto padrão, o seguinte arquivo de ignorar é 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 compilação, 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 compilação, 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 compilação

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

Gerar PDBs: para acelerar a compilação, o Live Unit Testing não gera PDBs durante as compilações. Esses arquivos de símbolo permitem que você vá para os rastreamentos de pilha quando ocorrem falhas de teste.
Compilar usando vários núcleos de CPU: por padrão, o Live Unit Testing executa compilações usando vários núcleos de CPU, o que melhora os tempos de compilação. 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 específica. Os testes podem ser cancelados automaticamente.
Usar 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ção

Configure o Live Unit Testing selecionando Ferramentas>Opções na barra de menu de nível superior do Visual Studio. No painel esquerdo da caixa de diálogo Opções, selecione Live Unit Testing.

Depois que o Live Unit Testing for habilitado (veja Iniciar, pausar e parar o Live Unit Testing), abra também a caixa de diálogo Opções selecionando Teste>Live Unit Testing>Opções.

A seguinte imagem mostra as opções de configuração do Live Unit Testing disponíveis na caixa de diálogo.

Captura de tela que mostra as opções de configuração do Live Unit Testing.

As opções configuráveis incluem:

Se o Live Unit Testing é pausado quando uma solução é criada e depurada.
Se o Live Unit Testing é pausado quando a energia da bateria do 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 sem log (None), somente mensagens de erro (Error), mensagens de erro e mensagens informativas (Info, o padrão) ou todos os detalhes (Verbose).

Também é possível exibir a saída detalhada na janela Saída do Live Unit Testing atribuindo um valor igual a 1 a uma variável de ambiente em 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 com o nome do arquivo que conterá o log.

Personalizar sua compilação para o Live Unit Testing

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

Adicionar substituições do Live Unit Testing

Se a solução exigir etapas personalizadas de compilação para instrumentação (Live Unit Testing) que não são necessárias para a compilação não instrumentada "normal", você poderá adicionar o código ao projeto ou arquivos .targets que verificam a propriedade BuildingForLiveUnitTesting e executam etapas de pré/pós-compilação personalizadas.

Por exemplo, você pode gravar a amostra 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 propriedade BuildingForLiveUnitTesting para desabilitar algumas tarefas que não devem ser executadas para compilações 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 não tenham sido copiados todos os arquivos necessários para a execução dos testes. O Live Unit Testing cria uma pasta separada em que executa testes. Essa disposição permite que as compilações ocorram enquanto os testes estão em execução, mas nem todos os arquivos da pasta de compilação 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 árvore de origem. Por exemplo, os testes examinam o conteúdo dos arquivos resx ou talvez ler alguns arquivos de configuração.
Seus testes dependem de algumas bibliotecas às quais 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 configuraçã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 propriedade LiveUnitTestingTestDependency 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 apenas copia Artifacts/Test_Project para a pasta de teste. Para adicionar fontes ou o console_utility à pasta de teste, adicione a amostra a seguir para 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 Teste>Live Unit Testing>Iniciar no menu de nível superior do Visual Studio. Quando o Live Unit Testing é habilitado, as opções disponíveis no menu Live Unit Testing mudam de um item, Iniciar, para Pausar e Parar:

Pausar suspende o Live Unit Testing temporariamente.

Quando o Live Unit Testing está em pausa, a visualização de cobertura não é exibida 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 ficar atualizado com todas as edições que foram feitas durante sua pausa e atualiza os glifos de forma adequada.
Parar para o Live Unit Testing por completo. O Live Unit Testing descarta todos os dados coletados.

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

A qualquer momento, é possível pausar temporariamente ou parar por completo 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 do Live Unit Testing é exibida e solicita que você selecione o conjunto de testes que você deseja testar pelo Live Unit Testing.

Captura de tela que mostra a janela de ferramentas exibida quando o Live Unit Testing é iniciado pela primeira vez.

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 com muitos projetos de teste, é possível controlar quais projetos e quais métodos individuais em um projeto farão parte do Live Unit Testing editando a playlist. Por exemplo, se você tiver uma solução com centenas de projetos de teste, será possível selecionar um conjunto direcionado de projetos de teste para fazer parte do Live Unit Testing.

Você escolhe o que 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 no código de teste

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

Janela de ferramentas do Live Unit Testing

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

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á em 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.

Captura de tela que mostra o editor de playlist do Live Unit Testing.

A janela do editor de código

É possível 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 <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:

Clique com o botão direito do mouse no Gerenciador de Soluções e escolha Live Unit Testing>Excluir para excluir toda a solução.
Clique com o botão direito do mouse em cada projeto de teste que deseja incluir nos testes e selecione Live Unit Testing>Incluir.

Programaticamente no código de teste

Você pode aplicar o atributo ExcludeFromCodeCoverageAttribute para excluir, de forma programática, 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 inteiro de testes do Live Unit Testing:

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

Exibir visualização de cobertura

Depois de habilitado, o Live Unit Testing atualiza cada linha de código no editor do Visual Studio para mostrar se o código que está sendo gravado é abrangido por testes de unidade e se os testes que os abrangem são aprovados.

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

Captura de tela que mostra o a cobertura de código no Visual Studio.

A visualização de cobertura do Live Unit Testing é atualizada imediatamente quando o código é modificado no editor de código. Durante o processamento das edições, a visualização é alterada para indicar que os dados não estão atualizados, com a adição de uma imagem de temporizador redondo abaixo dos símbolos de aprovado, não aprovado e não abrangido, como mostra a imagem a seguir.

Captura de tela que mostra a cobertura de código no Visual Studio com ícone de temporizador.

Obter informações sobre o status do teste

Ao passar o mouse sobre o símbolo de aprovação ou reprovação na janela de código, será possível ver quantos testes estão atingindo essa linha. Para ver o status dos testes individuais, selecione o símbolo.

Captura de tela que mostra o status de teste de um símbolo no Visual Studio.

Além de fornecer os nomes e o resultado dos testes, a dica de ferramenta permite executar novamente ou depurar o conjunto de testes. Se você selecionar um ou mais dos testes na dica de ferramenta, é possível executar ou depurar apenas esses testes. Essa ação permite que você depure seus testes sem precisar sair da janela de código.

Ao depurar, além de observar quaisquer pontos de interrupção que você tenha definido, a execução do programa pausará quando o depurador executar um método Assert que retorna um resultado inesperado.

Ao focalizar um teste com falha na dica de ferramenta, ele é expandido para fornecer informações adicionais sobre a falha, conforme mostrado na imagem a seguir. Para navegar diretamente para um teste com falha, clique duas vezes na dica de ferramenta.

Captura de tela que mostra informações de dica de ferramenta de teste com falha no Visual Studio.

Quando você navega para o teste com falha, o Live Unit Testing indica visualmente na assinatura do método os testes:

Aprovados (indicado por um béquer cheio até a metade junto com um "✓" verde").
Com falha (indicado por um béquer cheio até a metade junto com um "🞩" vermelho).
Não estão envolvidos no Live Unit Testing (indicado por um béquer cheio até a metade junto com um "➖" azul).

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

Captura de tela que mostra métodos de teste no Visual Studio com símbolo de aprovação ou reprovação.

Diagnosticar e corrigir falhas de teste

No teste com falha, é possível depurar o código do produto com facilidade, fazer edições e continuar desenvolvendo o aplicativo. Como o Live Unit Testing é executado em segundo plano, você não precisa parar e reiniciá-lo 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 caracteres não alfabéticos retornam true quando passados para o método System.Char.IsLower. Após você corrigir o método de teste, todos os testes devem ser aprovados. Você não precisa pausar nem parar o Live Unit Testing.

Janela do Live Unit Testing

O Live Unit Testing, semelhante ao Gerenciador de Testes, fornece uma interface que permite executar e depurar testes e analisar os resultados do 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 não está habilitado ou está parado, o Live Unit Testing exibe o status dos testes de unidade na última vez que um teste foi executado. Após você 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 Teste>Live Unit Testing>Iniciar no menu de nível superior do Visual Studio. Você também pode abrir a janela do Live Unit Testing usando Exibir>Outras Janelas>Janela do Live Unit Testing.

Você pode notar na janela do Live Unit Testing que alguns testes estão esmaecidos. 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.

Resultados de teste esmaecidos indicam que o teste não fazia parte da última execução do Live Unit Test. Os testes são executados apenas quando uma alteração no teste ou nas dependências do teste são detectadas. Se não houver nenhuma alteração, ele evitará executar o teste desnecessariamente. Nesse caso, o resultado do teste esmaecido ainda estará "atualizado", embora não tenha sido parte da última execução.

Captura de tela que mostra testes esmaecidos no Gerenciador de testes.

Você pode executar novamente todos os testes que aparecem esmaecidos fazendo uma alteração de código.

Há algumas diferenças entre a execução e atualização automáticas dos resultados de teste do Live Unit Testing e a execução explícita de testes no Gerenciador de Testes. Entre elas, podemos incluir:

Executar ou depurar testes da janela do Gerenciador de Testes executa binários normais. 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 Gerenciador de Testes criam um novo domínio de aplicativo.
O Live Unit Testing executa testes em cada assembly de teste sequencialmente. Na janela 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 enfileirará 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.