Compartilhar via

Executar testes em paralelo para qualquer executor de teste

  • Artigo

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 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 de execução prolongada – normalmente, esse é 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. Esse artigo discute como você pode colocar testes em paralelo usando vários agentes para processar trabalhos.

Pré-requisito

Familiarize-se com os conceitos de agentes e trabalhos. Cada agente pode executar apenas um trabalho por vez. Para executar vários trabalhos em paralelo, você deve configurar vários agentes. Você também precisa de trabalhos paralelos suficientes.

Configurando trabalhos paralelos

Especifique a estratégia "paralela" no YAML e indique quantos trabalhos devem ser expedidos. As variáveis System.JobPositionInPhase e System.TotalJobsInPhase são adicionadas a cada trabalho.

jobs:
- job: ParallelTesting
  strategy:
    parallel: 2

Dica

Você pode especificar até 99 agentes para escalar verticalmente os testes para grandes conjuntos de testes.

Fatiando o conjunto de testes

Para executar testes em paralelo, primeiro você deve fatiar (ou particionar) o conjunto de testes para que cada fatia possa ser executada de forma independente. Por exemplo, em vez de executar um grande conjunto de 1000 testes em um único agente, você pode usar dois agentes e executar 500 testes em paralelo em cada agente. Ou você pode reduzir ainda mais o tempo necessário para executar os testes usando 8 agentes e executando 125 testes em paralelo em cada agente.

A etapa que executa os testes em um trabalho precisa saber qual fatia de teste deve ser executada. As variáveis System.JobPositionInPhase e System.TotalJobsInPhase podem ser usadas para essa finalidade:

  • System.TotalJobsInPhase indica o número total de fatias (você pode considerar isso como "totalSlices")
  • System.JobPositionInPhase identifica uma fatia específica (você pode pensar nisso como "sliceNum")

Se você representar todos os arquivos de teste como uma única matriz dimensional, cada trabalho poderá executar um arquivo de teste indexado em [sliceNum + totalSlices], até que todos os arquivos de teste sejam executados. Por exemplo, se você tiver seis arquivos de teste e dois trabalhos paralelos, o primeiro trabalho (slice0) executará arquivos de teste numerados como 0, 2 e 4 e o segundo trabalho (slice1) executará arquivos de teste numerados como 1, 3 e 5.

6 testes em 2 fatias

Se você usar três trabalhos paralelos, o primeiro trabalho (slice0) executará arquivos de teste numerados como 0 e 3, o segundo trabalho (slice1) executará arquivos de teste numerados como 1 e 4 e o terceiro trabalho (slice2) executará arquivos de teste numerados 2 e 5.

6 testes em 3 fatias

Código de exemplo

Esse exemplo do .NET Core usa os parâmetros --list-tests e --filter de dotnet test para fatiar os testes. Os testes são executados usando NUnit. Os resultados do teste criados pela tarefa de teste DotNetCoreCLI@2 são publicados no servidor. Importe (para o Azure Repos ou Azure DevOps Server) ou fork (para o GitHub) neste repositório:

https://github.com/idubnori/ParallelTestingSample-dotnet-core

Esse exemplo do Python usa um script do PowerShell para fatiar os testes. Os testes são executados usando pytest. Os resultados de teste no estilo JUnit criados pelo pytest são publicados no servidor. Importe (para o Azure Repos ou Azure DevOps Server) ou fork (para o GitHub) neste repositório:

https://github.com/PBoraMSFT/ParallelTestingSample-Python

Esse exemplo de JavaScript usa um script bash para fatiar os testes. Os testes são executados usando o executor de mocha. Os resultados do teste no estilo JUnit criados pelo mocha são publicados no servidor. Importe (para o Azure Repos ou Azure DevOps Server) ou fork (para o GitHub) neste repositório:

https://github.com/PBoraMSFT/ParallelTestingSample-Mocha

O código de exemplo inclui um arquivo azure-pipelines.yml na raiz do repositório que você pode usar para criar um pipeline. Siga todas as instruções em Criar seu primeiro pipeline para criar um pipeline e ver a fatia de teste em ação.

Combinar paralelismo para testes paralelos maciços

Quando trabalhos paralelos são usados em um pipeline, o pipeline emprega vários computadores para executar cada trabalho em paralelo. A maioria dos executores de teste fornece a capacidade de executar testes em paralelo em um único computador (normalmente criando vários processos ou threads executados em paralelo). Os dois tipos de paralelismo podem ser combinados para testes paralelos maciços, o que torna o teste em pipelines extremamente eficiente.

Ajuda e suporte