Executar testes em paralelo usando a tarefa de teste do Visual Studio

Serviços de DevOps do Azure | Azure DevOps Server 2022 - Azure DevOps Server 2019

Executar testes para validar alterações no código é fundamental para manter a qualidade. Para que a prática de integração contínua seja bem-sucedida, é essencial que você tenha um bom conjunto de testes que seja executado com cada compilação. No entanto, à medida que a base de código cresce, o conjunto de testes de regressão tende a crescer também e a execução de um teste de regressão completa pode levar muito tempo. Às vezes, os testes em si podem ser de longa duração - este é normalmente o caso se você escrever testes de ponta a ponta. Isso reduz a velocidade com que o valor para o cliente pode ser entregue, já que os pipelines não podem processar compilações com rapidez suficiente.

Executar testes em paralelo é uma ótima maneira de melhorar a eficiência dos pipelines de CI/CD. Isso pode ser feito facilmente empregando a capacidade adicional oferecida pela nuvem. Este artigo descreve como você pode configurar a tarefa de teste do Visual Studio para executar testes em paralelo usando vários agentes.

Pré-requisito

Familiarize-se com os conceitos de agentes e empregos. Para executar vários trabalhos em paralelo, você deve configurar vários agentes. Você também precisa de trabalhos paralelos suficientes.

Teste de fatiamento

A tarefa de teste do Visual Studio (versão 2) foi projetada para funcionar perfeitamente com configurações de trabalho paralelo. Quando um trabalho de pipeline que contém a tarefa de teste do Visual Studio (referida como a "tarefa VSTest" para simplificar) é configurado para ser executado em vários agentes em paralelo, ele deteta automaticamente que vários agentes estão envolvidos e cria fatias de teste que podem ser executadas em paralelo entre esses agentes.

A tarefa pode ser configurada para criar fatias de teste para atender a diferentes requisitos, como processamento em lote com base no número de testes e agentes, nos tempos de execução de teste anteriores ou no local dos testes em montagens.

Essas opções são explicadas nas seções a seguir.

Fatiamento simples com base no número de testes e agentes

Essa configuração usa um algoritmo de fatiamento simples para dividir o número de testes 'T' entre os agentes 'N' para que cada agente execute testes T/N. Por exemplo, se o conjunto de testes contiver 1000 testes e você usar dois agentes para trabalhos paralelos, cada agente executará 500 testes. Ou você pode reduzir ainda mais o tempo necessário para executar os testes usando oito agentes, caso em que cada agente executa 125 testes em paralelo.

Esta opção é normalmente usada quando todos os testes têm tempos de execução semelhantes. Se os tempos de execução do teste não forem semelhantes, os agentes podem não ser utilizados de forma eficaz porque alguns agentes podem receber fatias com vários testes de longa duração, enquanto outros agentes podem receber fatias com testes de curta duração e terminar muito mais cedo do que o resto dos agentes.

Fatiamento com base no tempo de execução anterior dos testes

Essa configuração considera os tempos de execução anteriores para criar fatias de testes para que cada fatia tenha aproximadamente o mesmo tempo de execução. Os testes de curta duração serão agrupados em lote, enquanto os testes de longa duração serão alocados em fatias separadas.

Essa opção deve ser usada quando os testes dentro de um assembly não tiverem dependências e não precisarem ser executados no mesmo agente. Esta opção resulta na utilização mais eficiente dos agentes, porque cada agente recebe a mesma quantidade de 'trabalho' e todos terminam aproximadamente ao mesmo tempo.

Fatiamento com base em conjuntos de teste

Essa configuração usa um algoritmo de fatiamento simples que divide o número de assemblies de teste (ou arquivos) 'A' entre os agentes 'N', para que cada agente execute testes a partir de assemblies A/N. O número de testes dentro de um assembly não é levado em conta ao usar essa opção. Por exemplo, se o conjunto de testes contiver dez assemblies de teste e você usar dois agentes para trabalhos paralelos, cada agente receberá cinco assemblies de teste para executar. Você pode reduzir ainda mais o tempo necessário para executar os testes usando cinco agentes, caso em que cada agente recebe dois assemblies de teste para executar.

Essa opção deve ser usada quando os testes dentro de um assembly têm dependências ou utilizam AssemblyInitialize e AssemblyCleanup, ou ClassInitialize e ClassCleanup métodos, para gerenciar o estado em seu código de teste.

Execute testes em paralelo em pipelines de construção clássicos

Se você tiver um conjunto de testes grande ou testes de integração de longa execução para executar em seu pipeline de compilação clássico, use as etapas a seguir.

1. Crie tarefas usando um único agente. Crie projetos do Visual Studio e publique artefatos de compilação usando as tarefas mostradas na imagem a seguir. Isso usa as configurações de trabalho padrão (agente único, sem trabalhos paralelos).

   

2. Execute testes em paralelo usando vários agentes:

   • Adicionar um trabalho de agente

     

   • Configure o trabalho para usar vários agentes em paralelo. O exemplo aqui usa três agentes.

     

     Gorjeta

     Para testes paralelos massivos, você pode especificar até 99 agentes.

   • Adicione uma tarefa Download Build Artifacts ao trabalho. Esta etapa é o link entre o trabalho de compilação e o trabalho de teste, e é necessária para garantir que os binários gerados no trabalho de compilação estejam disponíveis nos agentes usados pelo trabalho de teste para executar testes. Verifique se a tarefa está definida para baixar artefatos produzidos pela 'Compilação atual' e se o nome do artefato é o mesmo que o nome do artefato usado na tarefa Publicar artefatos de compilação no trabalho de compilação.

     

   • Adicione a tarefa de teste do Visual Studio e configure-a para usar a estratégia de fatiamento necessária.

jobs:
- job: ParallelTesting
  strategy:
    parallel: 2

Execute testes em paralelo em pipelines de liberação clássicos

Use as etapas a seguir se você tiver um conjunto de testes grande ou testes funcionais de longa execução para executar após a implantação do aplicativo. Por exemplo, talvez você queira implantar um aplicativo Web e executar testes do Selenium em um navegador para validar a funcionalidade do aplicativo.

1. Implante o aplicativo usando um único agente. Use a Implantação do Azure: Criar ou Atualizar Grupo de Recursos ou a tarefa Implantar do Serviço de Aplicativo do Azure para implantar um aplicativo Web nos serviços do Aplicativo do Azure. Isso usa as configurações de trabalho padrão (agente único, sem trabalhos paralelos).

   

2. Execute testes em paralelo usando vários agentes:

   • Adicionar um trabalho de agente

     

   • Configure o trabalho para usar vários agentes em paralelo. O exemplo aqui usa três agentes.

     

     Gorjeta

     Para testes paralelos massivos, você pode especificar até 99 agentes.

   • Adicione quaisquer tarefas adicionais que devem ser executadas antes que a tarefa de teste do Visual Studio seja executada. Por exemplo, execute um script do PowerShell para configurar quaisquer dados exigidos pelos testes.

     Gorjeta

     Os trabalhos em pipelines de liberação baixam todos os artefatos vinculados ao pipeline de liberação por padrão. Para economizar tempo, você pode configurar o trabalho para baixar apenas os artefatos de teste exigidos pelo trabalho. Por exemplo, os binários do aplicativo Web não são necessários para executar testes do Selenium, e o download deles pode ser ignorado se o aplicativo e os artefatos de teste forem publicados separadamente pelo pipeline de compilação.

   • Adicione a tarefa de teste do Visual Studio e configure-a para usar a estratégia de fatiamento necessária.

     Gorjeta

     Se as máquinas de teste não tiverem o Visual Studio instalado, você poderá usar a tarefa Visual Studio Test Platform Installer para adquirir a versão necessária da plataforma de teste.

Testes paralelos massivos combinando trabalhos de pipeline paralelos com execução de testes paralelos

Quando trabalhos paralelos são usados em um pipeline, ele emprega várias máquinas (agentes) para executar cada trabalho em paralelo. Estruturas de teste e corredores também fornecem a capacidade de executar testes em paralelo em uma única máquina, normalmente criando vários processos ou threads que são executados em paralelo. Os recursos de paralelismo podem ser combinados de forma em camadas para obter testes paralelos em massa. No contexto da tarefa de teste do Visual Studio, o paralelismo pode ser combinado das seguintes maneiras:

1. Paralelismo oferecido por estruturas de teste. Todas as estruturas de teste modernas, como MSTest v2, NUnit, xUnit e outras, fornecem a capacidade de executar testes em paralelo. Normalmente, os testes em um assembly são executados em paralelo. Essas estruturas de teste fazem interface com a plataforma de teste do Visual Studio usando um adaptador de teste e a estrutura de teste, juntamente com o adaptador correspondente, e funcionam dentro de um processo de host de teste que a plataforma de teste do Visual Studio cria quando os testes são executados. Portanto, a paralelização nesta camada está dentro de um processo para todas as estruturas e adaptadores.

2. Paralelismo oferecido pela plataforma de teste do Visual Studio (vstest.console.exe). Visual Studio Test Platform pode executar assemblies de teste em paralelo. Os usuários do vstest.console.exe reconhecerão isso como a opção /parallel. Ele faz isso iniciando um processo de host de teste em cada núcleo disponível e entregando-lhe testes em um assembly para executar. Isso funciona para qualquer estrutura que tenha um adaptador de teste para a plataforma de teste do Visual Studio porque a unidade de paralelização é um assembly de teste ou arquivo de teste. Isso, quando combinado com o paralelismo oferecido pelas estruturas de teste (descritas acima), fornece o grau máximo de paralelização quando os testes são executados em um único agente no pipeline.

3. Paralelismo oferecido pela tarefa Visual Studio Test (VSTest). A tarefa VSTest suporta a execução de testes em paralelo em vários agentes (ou máquinas). As fatias de teste são criadas e cada agente executa uma fatia de cada vez. As três diferentes estratégias de fatiamento, quando combinadas com o paralelismo oferecido pela plataforma de teste e pela estrutura de teste (conforme descrito acima), resultam no seguinte:

   • Fatiamento com base no número de testes e agentes. Fatiamento simples onde os testes são agrupados em fatias de tamanho igual. Uma fatia contém testes de um ou mais assemblies. A execução do ensaio no agente obedece então ao paralelismo descrito nos pontos 1 e 2 supra.

   • Fatiamento com base no tempo de execução passado. Com base nos tempos anteriores para a execução de testes e no número de agentes disponíveis, os testes são agrupados em fatias de modo que cada fatia exija aproximadamente o mesmo tempo de execução. Uma fatia contém testes de um ou mais assemblies. A execução do ensaio no agente obedece então ao paralelismo descrito nos pontos 1 e 2 supra.

   • Fatiamento com base em montagens. Uma fatia é um conjunto de teste e, portanto, contém testes que pertencem todos ao mesmo conjunto. A execução sobre o agente obedece então ao paralelismo descrito nos pontos 1 e 2 supra. No entanto, 2 pode não ocorrer se um agente receber apenas um assembly para ser executado.

Ajuda e suporte

• Consulte a nossa página de resolução de problemas
• Obtenha conselhos sobre o Stack Overflow e obtenha suporte através da Comunidade de Programadores