Executar testes em paralelo usando a tarefa teste do Visual Studio

Azure DevOps Services | Azure DevOps Server | Azure DevOps Server 2022

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 a cada build. No entanto, à medida que a base de código aumenta, 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 próprios testes podem ser executados por muito tempo , normalmente é o caso se você escreve testes de ponta a ponta. Isso reduz a velocidade com que o valor do cliente pode ser entregue, pois os pipelines não podem processar builds rapidamente o 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 discute como você pode configurar a tarefa teste do Visual Studio para executar testes em paralelo usando vários agentes.

Pré-requisito

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

Fatiamento de teste

A tarefa teste do Visual Studio (versão 2) foi projetada para funcionar perfeitamente com configurações de trabalho paralelas. Quando um trabalho de pipeline que contém a tarefa teste do Visual Studio (conhecida como "tarefa VSTest" para simplificar) é configurado para ser executado em vários agentes em paralelo, ele detecta 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 envio 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 assemblies.

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 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, nesse caso, cada agente executa 125 testes em paralelo.

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

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

Essa configuração considera 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 execução curta serão agrupados em lote, enquanto os testes de execução longa serão alocados para fatias separadas.

Essa opção deve ser usada quando os testes em um assembly não têm dependências e não precisam ser executados no mesmo agente. Essa opção resulta na utilização mais eficiente dos agentes porque cada agente obtém a mesma quantidade de "trabalho" e todos terminam aproximadamente ao mesmo tempo.

Fatiamento com base em assemblies de teste

Essa configuração usa um algoritmo de fatiamento simples que divide o número de assemblies de teste (ou arquivos) 'A' em agentes 'N', para que cada agente execute testes de assemblies A/N. O número de testes em 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 execução. Você pode reduzir ainda mais o tempo necessário para executar os testes usando cinco agentes, caso em que cada agente obtém dois assemblies de teste para execução.

Essa opção deve ser usada quando os testes em 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.

Executar testes em paralelo em pipelines de build clássicos

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

1. Compilar trabalho usando um único agente. Crie projetos do Visual Studio e publique artefatos de build 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.

     

     Dica

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

   • Adicione uma tarefa Baixar Artefatos de Build ao trabalho. Esta etapa é o vínculo entre o trabalho de build e o trabalho de teste e é necessário para garantir que os binários gerados no trabalho de build estejam disponíveis nos agentes usados pelo trabalho de teste para executar testes. Verifique se a tarefa está definida para baixar artefatos produzidos pelo 'Build atual' e se o nome do artefato é o mesmo que o nome do artefato usado na tarefa Publicar Artefatos de Build no trabalho de build.

     

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

jobs:
- job: ParallelTesting
  strategy:
    parallel: 2

Executar testes em paralelo em pipelines de versão clássicos

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

1. Implantar o aplicativo usando um único agente. Use a Implantação do Azure: criar ou atualizar o Grupo de Recursos ou a tarefa Implantar Serviço de Aplicativo do Azure para implantar um aplicativo Web nos serviços de 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.

     

     Dica

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

   • Adicione quaisquer tarefas adicionais que devem ser executadas antes da execução da tarefa de teste do Visual Studio. Por exemplo, execute um script do PowerShell para configurar todos os dados necessários para seus testes.

     Dica

     Os trabalhos em pipelines de versão baixam todos os artefatos vinculados ao pipeline de lançamento por padrão. Para economizar tempo, você pode configurar o trabalho para baixar apenas os artefatos de teste exigidos pelo trabalho. Por exemplo, binários de aplicativo Web não são necessários para executar testes selenium e baixá-los pode ser ignorado se o aplicativo e os artefatos de teste forem publicados separadamente pelo pipeline de build.

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

     Dica

     Se os computadores de teste não tiverem o Visual Studio instalado, você poderá usar a tarefa Instalador da Plataforma de Teste do Visual Studio para adquirir a versão necessária da plataforma de teste.

Teste paralelo maciço combinando trabalhos de pipeline paralelos com execução de teste paralela

Quando trabalhos paralelos são usados em um pipeline, ele emprega vários computadores (agentes) para executar cada trabalho em paralelo. Estruturas de teste e executores também fornecem a capacidade de executar testes em paralelo em um único computador, 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 maciços. No contexto da tarefa 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 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 nessa 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). A Plataforma de Teste do Visual Studio pode executar assemblies de teste em paralelo. Os usuários de 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 testes em um assembly para execução. 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 por estruturas de teste (descrito 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 VSTest (Teste do Visual Studio). A tarefa VSTest dá suporte à execução de testes em paralelo em vários agentes (ou computadores). As fatias de teste são criadas e cada agente executa uma fatia por vez. As três estratégias de fatiamento diferentes, 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. Corte simples em que os testes são agrupados em fatias de tamanho igual. Uma fatia contém testes de um ou mais assemblies. A execução de teste no agente está em conformidade com o paralelismo descrito em 1 e 2 acima.

   • Fatiamento com base no tempo de execução anterior. 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 um tempo de execução aproximadamente igual. Uma fatia contém testes de um ou mais assemblies. A execução de teste no agente está em conformidade com o paralelismo descrito em 1 e 2 acima.

   • Fatiamento com base em assemblies. Uma fatia é um assembly de teste e, portanto, contém testes que pertencem ao mesmo assembly. Em seguida, a execução no agente está em conformidade com o paralelismo descrito em 1 e 2 acima. No entanto, 2 podem não ocorrer se um agente receber apenas um assembly a ser executado.

Ajuda e suporte

• Consulte nossa página de solução de problemas
• Obtenha conselhos sobre o Stack Overflow e obtenha suporte por meio da Comunidade de Desenvolvedores