Executar testes em paralelo usando a tarefa Visual Studio Test

Azure DevOps Services | 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 executado com cada build. 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 ter execução prolongada, o que normalmente acontece 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 de 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 Visual Studio Test (versão 2) foi projetada para funcionar perfeitamente com configurações de trabalho paralelo. Quando um trabalho de pipeline que contém a tarefa Visual Studio Test (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 lotes com base no número de testes e agentes, tempos de execução de teste anteriores ou localização de testes em montagens.

As 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 1.000 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 executará 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 tiverem dependências e não precisarem ser executados no mesmo agente. Essa opção resulta na utilização mais eficiente dos agentes, pois 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 receberá dois assemblies de teste para execução.

Essa opção deve ser usada quando os testes em um assembly tiverem dependências ou utilizarem os métodos AssemblyInitialize e AssemblyCleanup, ou ClassInitialize e ClassCleanup, 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. Criar trabalho usando um único agente. Crie projetos do Visual Studio e publique artefatos de compilação usando as tarefas mostradas na imagem a seguir. As configurações de trabalho padrão (agente único, sem trabalhos paralelos) são usadas.

   

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

   • Adicionar um trabalho do 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 Compilação ao trabalho. Esta etapa é o vínculo 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 por '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 Teste do Visual Studio e configure-a para usar o fatiamento de divisão necessário.

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 da 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 tarefa Implantação do Azure: Criar ou atualizar grupo de recursos ou Implantar do Serviço de Aplicativo do Azure para implantar um aplicativo Web nos Serviços de Aplicativo do Azure. As configurações de trabalho padrão (agente único, sem trabalhos paralelos) são usadas.

   

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

   • Adicionar um trabalho do 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 Visual Studio Test. Por exemplo, execute um script do PowerShell para configurar todos os dados necessários para seus testes.

     Dica

     Trabalhos em pipelines de lançamento 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, os binários de aplicativos 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 por seu pipeline de build.

   • Adicione a tarefa Teste do Visual Studio e configure-a para usar o fatiamento de divisão necessário.

     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.

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

Quando trabalhos paralelos são usados em um pipeline, ele emprega vários computadores (agentes) para executar cada trabalho em paralelo. Estruturas e executores de teste também fornecem a capacidade de executar testes em paralelo em um único computador, normalmente criando vários processos ou threads executados em paralelo. Os recursos de paralelismo podem ser combinados em camadas para obter testes paralelos massivos. 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, oferecem a capacidade de executar testes em paralelo. Normalmente, os testes em um assembly são executados em paralelo. Essas estruturas de teste interagem 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 em 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 do vstest.console.exe reconhecerão isso como a opção /parallel switch. 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 pelas 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 tarefaVSTest (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 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 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 dos 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. A execução no agente está em conformidade com o paralelismo descrito em 1 e 2 acima. No entanto, 2 pode não ocorrer se um agente receber apenas um assembly a ser executado.

Ajuda e suporte

• Confira nossa página de solução de problemas
• Obtenha conselhos sobre Stack Overflow e obtenha suporte por meio do Developer Community