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

Serviços de DevOps do Azure | 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 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 se pode entregar valor ao cliente, já que os pipelines não conseguem processar as construçõ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 discute como é possível configurar a tarefa de Teste do Visual Studio para executar testes em paralelo usando múltiplos agentes.

Pré-requisito

Familiarize-se com os conceitos de agentes e cargos. 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.

Segmentação 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.

Divisão 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 métodos ClassInitialize e ClassCleanup, para gerenciar o estado em seu código de teste.

Executar testes em paralelo em pipelines de desenvolvimento 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. Executar tarefa com 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 em paralelo vários agentes. O exemplo aqui usa três agentes.

     ParallelTestJobBuild

     Tip

     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 necessária estratégia de fatiamento de .

jobs:
- job: ParallelTesting
  strategy:
    parallel: 2

Corra testes em paralelo em pipelines de lançamento 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. Implantar aplicativo usando um único agente. Utilize a funcionalidade 'Criar ou Atualizar Grupo de Recursos' ou a tarefa 'Implantar do Serviço de Aplicativos do Azure' para implantar uma aplicação web nos Serviços de Aplicativos 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 em paralelo vários agentes. O exemplo aqui usa três agentes.

     

     Tip

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

   • Adicione 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.

     Tip

     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 da aplicação web não são necessários para executar testes do Selenium, e o seu download pode ser ignorado se a aplicação e os artefatos de teste forem publicados separadamente pelo pipeline de build.

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

     Tip

     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.

Testagem paralela em massa combinando trabalhos de pipeline paralelos com execução paralela de testes

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 utilizadores do vstest.console.exe reconhecerão isto como o interruptor /parallel. Ele faz isso iniciando um processo de host de teste em cada núcleo disponível e fornecendo-lhe testes em um conjunto para serem executados. Isso funciona para qualquer framework que tenha um adaptador de teste para a plataforma de teste do Visual Studio porque a unidade de paralelização é uma assembly 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. O 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 secção contém testes de um ou mais conjuntos. A execução do ensaio no agente está então em conformidade com o paralelismo descrito nos 1 e 2 acima.

   • Corte 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 aproximadamente o mesmo tempo de execução. Uma secção contém testes de um ou mais conjuntos. A execução do ensaio no agente está então em conformidade com o paralelismo descrito nos 1 e 2 acima.

   • 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 1 e 2 acima. No entanto, 2 pode não ocorrer se um agente receber apenas uma montagem para ser executada.

Ajuda e suporte

• Consulte a nossa página de resolução de problemas
• Obtenha aconselhamento sobre o Stack Overflowe obtenha suporte através da Comunidade de Desenvolvedores