As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Exemplo de execução de testes em paralelo para vários frameworks de teste
<a name="sample-parallel-test"></a>

É possível usar o comando `codebuild-tests-run` da CLI para dividir e executar testes em ambientes de execução paralela. A seção a seguir fornece exemplos de `buildspec.yml` de vários frameworks, ilustrando o uso do comando `codebuild-tests-run`.
+ Cada exemplo abaixo inclui um nível de `parallelism` de cinco, o que significa que cinco ambientes de execução idênticos serão criados para dividir os testes. É possível escolher um nível de `parallelism` adequado ao projeto modificando o valor de `parallelism` na seção `build-fanout`.
+ Cada exemplo abaixo mostra como configurar os testes para serem divididos pelo nome do arquivo de teste, que é o padrão. Isso distribui os testes uniformemente nos ambientes de execução paralela.

Antes de começar, consulte mais informações em [Executar testes paralelos em compilações em lote](parallel-test.md).

Consulte uma lista completa das opções ao usar o comando `codebuild-tests-run` da CLI em [Usar o comando `codebuild-tests-run` da CLI](parallel-test-tests-run.md).

**Topics**
+ [Configurar testes em paralelo com o Django](sample-parallel-test-django.md)
+ [Configurar testes em paralelo com o Elixir](sample-parallel-test-elixir.md)
+ [Configurar testes em paralelo com o Go](sample-parallel-test-go.md)
+ [Configurar testes paralelos com Java (Maven)](sample-parallel-test-java-maven.md)
+ [Configurar testes paralelos com Javascript (Jest)](sample-parallel-test-javascript.md)
+ [Configurar testes em paralelo com o Kotlin](sample-parallel-test-kotlin.md)
+ [Configurar testes em paralelo com o PHPUnit](sample-parallel-test-phpunit.md)
+ [Configurar testes em paralelo com o Pytest](sample-parallel-test-python.md)
+ [Configurar testes em paralelo com o Ruby (Cucumber)](sample-parallel-test-ruby-cucumber.md)
+ [Configurar testes em paralelo com o Ruby (RSpec)](sample-parallel-test-ruby.md)

# Configurar testes em paralelo com o Django
<a name="sample-parallel-test-django"></a>

Veja a seguir uma amostra de um `buildspec.yml` que mostra a execução de testes em paralelo com o Django em uma plataforma Ubuntu:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 5

phases:
  install:
    commands:
      - echo 'Installing Python dependencies'
      - sudo yum install -y python3 python3-pip 
      - python3 -m ensurepip --upgrade 
      - python3 -m pip install django
  pre_build:
    commands:
      - echo 'Prebuild'
  build:
    commands:
      - echo 'Running Django Tests'
      - |
        codebuild-tests-run \
         --test-command 'python3 manage.py test $(echo "$CODEBUILD_CURRENT_SHARD_FILES" | sed -E "s/\//__/g; s/\.py$//; s/__/./g")' \ 
         --files-search "codebuild-glob-search '**/tests/*test_*.py'" \
         --sharding-strategy 'equal-distribution'
  post_build:
    commands:
      - echo 'Test execution completed'
```

O exemplo acima mostra o uso da variável de ambiente `CODEBUILD_CURRENT_SHARD_FILES`. Aqui, `CODEBUILD_CURRENT_SHARD_FILES` é usado para obter caminhos de arquivos em notação com pontos compatíveis com o Django. Use `CODEBUILD_CURRENT_SHARD_FILES` entre aspas duplas, conforme mostrado acima.

# Configurar testes em paralelo com o Elixir
<a name="sample-parallel-test-elixir"></a>

Veja a seguir uma amostra de um `buildspec.yml` que mostra a execução de testes em paralelo com o Elixir em uma plataforma Ubuntu:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 5

phases:
  install:
    commands:
      - echo 'Installing Elixir dependencies'
      - sudo apt update
      - sudo DEBIAN_FRONTEND=noninteractive apt install -y elixir
      - elixir --version
      - mix --version
  pre_build:
    commands:
      - echo 'Prebuild'
  build:
    commands:
      - echo 'Running Elixir Tests'
      - |
        codebuild-tests-run \
         --test-command 'mix test' \
         --files-search "codebuild-glob-search '**/test/**/*_test.exs'" \ 
         --sharding-strategy 'equal-distribution'
  post_build:
    commands:
      - echo "Test execution completed"
```

# Configurar testes em paralelo com o Go
<a name="sample-parallel-test-go"></a>

Veja a seguir uma amostra de um `buildspec.yml` que mostra a execução de testes em paralelo com o Go em uma plataforma Linux:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 5
    ignore-failure: false

phases:
  install:
    commands:
      - echo 'Fetching Go version'
      - go version
  pre_build:
    commands:
      - echo 'prebuild'
  build:
    commands:
      - echo 'Running go Tests'
      - go mod init calculator
      - cd calc
      - |
        codebuild-tests-run \
         --test-command "go test -v calculator.go" \
         --files-search "codebuild-glob-search '**/*test.go'"
  post_build:
    commands:
      - echo "Test execution completed"
```

No exemplo acima, a função `calculator.go` contém funções matemáticas simples para testar e todos os arquivos de teste e arquivos `calculator.go` estão dentro da pasta `calc`.

# Configurar testes paralelos com Java (Maven)
<a name="sample-parallel-test-java-maven"></a>

Veja a seguir uma amostra de um `buildspec.yml` que mostra a execução de testes em paralelo com o Java em uma plataforma Linux:

```
version: 0.2

batch:
  fast-fail: false 
  build-fanout:
    parallelism: 5
    ignore-failure: false
    
phases:
  pre_build:
    commands:
      - echo 'prebuild'
  build:
    commands:
      - echo "Running mvn test"
      - |
        codebuild-tests-run \
          --test-command 'mvn test -Dtest=$(echo "$CODEBUILD_CURRENT_SHARD_FILES" | sed "s|src/test/java/||g; s/\.java//g; s|/|.|g; s/ /,/g" | tr "\n" "," | sed "s/,$//")' \
          --files-search "codebuild-glob-search '**/test/**/*.java'"
         
  post_build:
    commands:
      - echo "Running post-build steps..."
      - echo "Test execution completed"
```

No exemplo fornecido, a variável de ambiente `CODEBUILD_CURRENT_SHARD_FILES` contém arquivos de teste no fragmento atual, separados por quebras de linha. Esses arquivos são convertidos em uma lista separada por vírgulas de nomes de classes no formato aceito pelo parâmetro `-Dtest` do Maven.

# Configurar testes paralelos com Javascript (Jest)
<a name="sample-parallel-test-javascript"></a>

Veja a seguir uma amostra de um `buildspec.yml` que mostra a execução de testes em paralelo com o Javascript em uma plataforma Ubuntu:

```
version: 0.2

batch:
  fast-fail: true
  build-fanout:
    parallelism: 5
    ignore-failure: false

phases:
  install:
    commands:
      - echo 'Installing Node.js dependencies'
      - apt-get update
      - apt-get install -y nodejs
      - npm install
      - npm install --save-dev jest-junit
  pre_build:
    commands:
      - echo 'prebuild'
  build:
    commands:
      - echo 'Running JavaScript Tests'
      - |
         codebuild-tests-run \
          --test-command "npx jest" \
          --files-search "codebuild-glob-search '**/test/**/*.test.js'" \
          --sharding-strategy 'stability'
    post_build:
      commands:
        - echo 'Test execution completed'
```

# Configurar testes em paralelo com o Kotlin
<a name="sample-parallel-test-kotlin"></a>

Veja a seguir uma amostra de um `buildspec.yml` que mostra a execução de testes em paralelo com o Kotlin em uma plataforma Linux:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 2
    ignore-failure: false

phases:
  install:
    runtime-versions:
      java: corretto11 
    commands:
      - echo 'Installing dependencies'
      - KOTLIN_VERSION="1.8.20" # Replace with your desired version
      - curl -o kotlin-compiler.zip -L "https://github.com/JetBrains/kotlin/releases/download/v${KOTLIN_VERSION}/kotlin-compiler-${KOTLIN_VERSION}.zip"
      - unzip kotlin-compiler.zip -d /usr/local
      - export PATH=$PATH:/usr/local/kotlinc/bin
      - kotlin -version
      - curl -O https://repo1.maven.org/maven2/org/junit/platform/junit-platform-console-standalone/1.8.2/junit-platform-console-standalone-1.8.2.jar
  pre_build:
    commands:
      - echo 'prebuild'
  build:
    commands:
      - echo 'Running Kotlin Tests'
      - |
        codebuild-tests-run \
          --test-command 'kotlinc src/main/kotlin/*.kt $(echo "$CODEBUILD_CURRENT_SHARD_FILES" | tr "\n" " ") -d classes -cp junit-platform-console-standalone-1.8.2.jar' \
          --files-search "codebuild-glob-search 'src/test/kotlin/*.kt'"
      - |
        codebuild-tests-run \
          --test-command '
            java -jar junit-platform-console-standalone-1.8.2.jar --class-path classes \
              $(for file in $CODEBUILD_CURRENT_SHARD_FILES; do
                 class_name=$(basename "$file" .kt)
                 echo "--select-class $class_name"
               done)
          ' \
          --files-search "codebuild-glob-search 'src/test/kotlin/*.kt'"
  post_build:
    commands:
      - echo "Test execution completed"
```

No exemplo acima, a CLI `codebuild-tests-run` é usada duas vezes. Durante a primeira execução, o kotlinc compila os arquivos. A variável `CODEBUILD_CURRENT_SHARD_FILES` recupera os arquivos de teste atribuídos ao fragmento atual, que são então convertidos em uma lista separada por espaços. Na segunda execução, o JUnit executa os testes. Novamente, `CODEBUILD_CURRENT_SHARD_FILES` busca os arquivos de teste atribuídos ao fragmento atual, mas dessa vez eles são convertidos em nomes de classe.

# Configurar testes em paralelo com o PHPUnit
<a name="sample-parallel-test-phpunit"></a>

Veja a seguir uma amostra de um `buildspec.yml` que mostra a execução de testes em paralelo com o PHPUnit em uma plataforma Linux:

```
version: 0.2
 
batch:
   fast-fail: false
   build-fanout:
     parallelism: 5
     ignore-failure: false
 
phases:
   install:
     commands:
       - echo 'Install dependencies'
       - composer require --dev phpunit/phpunit
   pre_build:
     commands:
       - echo 'prebuild'
   build:
     commands:
       - echo 'Running phpunit Tests'
       - composer dump-autoload
       - | 
         codebuild-tests-run \
          --test-command "./vendor/bin/phpunit --debug" \ 
          --files-search "codebuild-glob-search '**/tests/*Test.php'"
   post_build:
       commands:
         - echo 'Test execution completed'
```

# Configurar testes em paralelo com o Pytest
<a name="sample-parallel-test-python"></a>

Veja a seguir uma amostra de um `buildspec.yml` que mostra a execução de testes em paralelo com o Pytest em uma plataforma Ubuntu:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 5
    ignore-failure: false

phases:
  install:
    commands:
      - echo 'Installing Python dependencies'
      - apt-get update
      - apt-get install -y python3 python3-pip
      - pip3 install --upgrade pip
      - pip3 install pytest
  build:
    commands:
      - echo 'Running Python Tests'
      - |
         codebuild-tests-run \
          --test-command 'python -m pytest' \
          --files-search "codebuild-glob-search 'tests/test_*.py'" \
          --sharding-strategy 'equal-distribution'
  post_build:
    commands:
      - echo "Test execution completed"
```

Veja a seguir uma amostra de um `buildspec.yml` que mostra a execução de testes em paralelo com o Pytest em uma plataforma Windows:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 5
    ignore-failure: false

phases:
  install:
    commands:
      - echo 'Installing Python dependencies'
      - pip install pytest
  pre_build:
    commands:
      - echo 'prebuild'
  build:
    commands:
      - echo 'Running pytest'
      - |
        & codebuild-tests-run `
         --test-command 'pytest @("$env:CODEBUILD_CURRENT_SHARD_FILES" -split \"`r?`n\")'  `
         --files-search "codebuild-glob-search '**/test_*.py' '**/*_test.py'" `
         --sharding-strategy 'equal-distribution' 
  post_build:
    commands:
      - echo "Test execution completed"
```

No exemplo acima, a variável de ambiente `CODEBUILD_CURRENT_SHARD_FILES` é usada para buscar arquivos de teste atribuídos ao fragmento atual e passados como matriz para o comando pytest.

# Configurar testes em paralelo com o Ruby (Cucumber)
<a name="sample-parallel-test-ruby-cucumber"></a>

Veja a seguir uma amostra de um `buildspec.yml` que mostra a execução de testes em paralelo com o Cucumber em uma plataforma Linux:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 5
    ignore-failure: false

phases:
  install:
    commands:
      - echo 'Installing Ruby dependencies'
      - gem install bundler
      - bundle install
  pre_build:
    commands:
      - echo 'prebuild'
  build:
    commands:
      - echo 'Running Cucumber Tests'
      - cucumber --init
      - |
        codebuild-tests-run \
         --test-command "cucumber" \
         --files-search "codebuild-glob-search '**/*.feature'"
  post_build:
    commands:
      - echo "Test execution completed"
```

# Configurar testes em paralelo com o Ruby (RSpec)
<a name="sample-parallel-test-ruby"></a>

Veja a seguir uma amostra de um `buildspec.yml` que mostra a execução de testes em paralelo com o RSpec em uma plataforma Ubuntu:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 5
    ignore-failure: false

phases:
  install:
    commands:
      - echo 'Installing Ruby dependencies'
      - apt-get update
      - apt-get install -y ruby ruby-dev build-essential
      - gem install bundler
      - bundle install
  build:
    commands:
      - echo 'Running Ruby Tests'
      - |
         codebuild-tests-run \
          --test-command 'bundle exec rspec' \
          --files-search "codebuild-glob-search 'spec/**/*_spec.rb'" \
          --sharding-strategy 'equal-distribution'
  post_build:
    commands:
      - echo "Test execution completed"
```