Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Ejemplo de ejecución de pruebas paralelas para varios marcos de prueba
<a name="sample-parallel-test"></a>

Puede utilizar el comando `codebuild-tests-run` de la CLI para dividir y ejecutar pruebas en entornos de ejecución paralelos. En la siguiente sección, se proporcionan ejemplos de `buildspec.yml` para varios marcos que ilustran el uso del comando `codebuild-tests-run`.
+ Cada uno de los siguientes ejemplos incluye un nivel de `parallelism` de cinco, lo que significa que se crearán cinco entornos de ejecución idénticos para dividir las pruebas. Puede elegir un nivel de `parallelism` que se ajuste a su proyecto modificando el valor de `parallelism` en la sección `build-fanout`.
+ En cada uno de los ejemplos siguientes se muestra la configuración de las pruebas para que se dividan por nombre del archivo de prueba, que es el predeterminado. Esto distribuye las pruebas de manera uniforme entre los entornos de ejecución paralelos.

Antes de empezar, consulte [Ejecución de pruebas paralelas en compilaciones por lotes](parallel-test.md) para obtener más información.

Para obtener una lista completa de opciones al utilizar el comando `codebuild-tests-run` de la CLI, consulte [Uso del comando `codebuild-tests-run` de la CLI](parallel-test-tests-run.md).

**Topics**
+ [Configuración de pruebas paralelas con Django](sample-parallel-test-django.md)
+ [Configuración de pruebas paralelas con Elixir](sample-parallel-test-elixir.md)
+ [Configuración de pruebas paralelas con Go](sample-parallel-test-go.md)
+ [Configuración de pruebas paralelas con Java (Maven)](sample-parallel-test-java-maven.md)
+ [Configuración de pruebas paralelas con Javascript (Jest)](sample-parallel-test-javascript.md)
+ [Configuración de pruebas paralelas con Kotlin](sample-parallel-test-kotlin.md)
+ [Configuración de pruebas paralelas con PHPUnit](sample-parallel-test-phpunit.md)
+ [Configuración de pruebas paralelas con Pytest](sample-parallel-test-python.md)
+ [Configuración de pruebas paralelas con Ruby (Cucumber)](sample-parallel-test-ruby-cucumber.md)
+ [Configuración de pruebas paralelas con Ruby (Cucumber)](sample-parallel-test-ruby.md)

# Configuración de pruebas paralelas con Django
<a name="sample-parallel-test-django"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Django en una 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'
```

El ejemplo anterior muestra el uso de la variable de entorno `CODEBUILD_CURRENT_SHARD_FILES`. Aquí `CODEBUILD_CURRENT_SHARD_FILES` se usa para obtener rutas de archivo de notación de puntos de recuperación compatibles con Django. Use `CODEBUILD_CURRENT_SHARD_FILES` entre comillas dobles como se muestra arriba.

# Configuración de pruebas paralelas con Elixir
<a name="sample-parallel-test-elixir"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Elixir en una 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"
```

# Configuración de pruebas paralelas con Go
<a name="sample-parallel-test-go"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Go en una 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"
```

En el ejemplo anterior, la función `calculator.go` contiene funciones matemáticas simples para probar todos los archivos de prueba y el archivo `calculator.go` está en una carpeta `calc`.

# Configuración de pruebas paralelas con Java (Maven)
<a name="sample-parallel-test-java-maven"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Java en una 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"
```

En el ejemplo dado, la variable de entorno `CODEBUILD_CURRENT_SHARD_FILES` contiene archivos de prueba en la partición actual, separados por líneas. Estos archivos se convierten en una lista de nombres de clases separados por comas en el formato aceptado por el parámetro `-Dtest` para Maven.

# Configuración de pruebas paralelas con Javascript (Jest)
<a name="sample-parallel-test-javascript"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Javascript en una 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'
```

# Configuración de pruebas paralelas con Kotlin
<a name="sample-parallel-test-kotlin"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Kotlin en una 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"
```

En el ejemplo anterior, la `codebuild-tests-run` CLI se usa dos veces. Durante la primera ejecución, kotlinc compila los archivos. La variable `CODEBUILD_CURRENT_SHARD_FILES` recupera los archivos de prueba asignados a la partición actual, que luego se convierten en una lista separada por espacios. En la segunda ejecución, JUnit ejecuta las pruebas. Una vez más, `CODEBUILD_CURRENT_SHARD_FILES` recupera los archivos de prueba asignados a la partición actual, pero esta vez se convierten en nombres de clases.

# Configuración de pruebas paralelas con PHPUnit
<a name="sample-parallel-test-phpunit"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con PHPUnit en una 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'
```

# Configuración de pruebas paralelas con Pytest
<a name="sample-parallel-test-python"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Pytest en una 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"
```

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Pytest en una 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"
```

En el ejemplo anterior, la variable de entorno `CODEBUILD_CURRENT_SHARD_FILES` se utiliza para recuperar los archivos de prueba asignados a la partición actual y pasarlos como matriz al comando pytest.

# Configuración de pruebas paralelas con Ruby (Cucumber)
<a name="sample-parallel-test-ruby-cucumber"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Cucumber en una 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"
```

# Configuración de pruebas paralelas con Ruby (Cucumber)
<a name="sample-parallel-test-ruby"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con RSpec en una 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"
```