Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Exemple d'exécution de tests en parallèle pour différents frameworks de test
<a name="sample-parallel-test"></a>

Vous pouvez utiliser la commande `codebuild-tests-run` CLI pour diviser et exécuter vos tests dans des environnements d'exécution parallèles. La section suivante fournit `buildspec.yml` des exemples de différents frameworks, illustrant l'utilisation de la `codebuild-tests-run` commande.
+ Chaque exemple ci-dessous inclut un `parallelism` niveau de cinq, ce qui signifie que cinq environnements d'exécution identiques seront créés pour répartir vos tests. Vous pouvez choisir un `parallelism` niveau adapté à votre projet en modifiant la `parallelism` valeur dans la `build-fanout` section.
+ Chaque exemple ci-dessous montre comment configurer vos tests pour qu'ils soient divisés par le nom du fichier de test, qui est par défaut. Cela répartit les tests de manière uniforme dans les environnements d'exécution parallèle.

Avant de commencer, consultez [Exécuter des tests parallèles dans des builds par lots](parallel-test.md) pour plus d'informations.

Pour obtenir la liste complète des options disponibles lors de l'utilisation de la commande `codebuild-tests-run` CLI, consultez[Utilisez la `codebuild-tests-run` commande CLI](parallel-test-tests-run.md).

**Topics**
+ [Configurer des tests parallèles avec Django](sample-parallel-test-django.md)
+ [Configurer des tests parallèles avec Elixir](sample-parallel-test-elixir.md)
+ [Configurer des tests parallèles avec Go](sample-parallel-test-go.md)
+ [Configuration de tests parallèles avec Java (Maven)](sample-parallel-test-java-maven.md)
+ [Configurer des tests parallèles avec Javascript (Jest)](sample-parallel-test-javascript.md)
+ [Configurer des tests parallèles avec Kotlin](sample-parallel-test-kotlin.md)
+ [Configurez des tests parallèles avec PHPUnit](sample-parallel-test-phpunit.md)
+ [Configurer des tests parallèles avec Pytest](sample-parallel-test-python.md)
+ [Configurer des tests parallèles avec Ruby (Cucumber)](sample-parallel-test-ruby-cucumber.md)
+ [Configurer des tests parallèles avec Ruby (RSpec)](sample-parallel-test-ruby.md)

# Configurer des tests parallèles avec Django
<a name="sample-parallel-test-django"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle avec Django sur une plate-forme 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'
```

L'exemple ci-dessus montre l'utilisation de la variable d'environnement`CODEBUILD_CURRENT_SHARD_FILES`. Ici `CODEBUILD_CURRENT_SHARD_FILES` est utilisé pour récupérer les chemins des fichiers de notation par points supportés par Django. Utilisez des guillemets doubles `CODEBUILD_CURRENT_SHARD_FILES` à l'intérieur, comme indiqué ci-dessus.

# Configurer des tests parallèles avec Elixir
<a name="sample-parallel-test-elixir"></a>

Voici un exemple de test `buildspec.yml` illustrant l'exécution parallèle d'un test avec Elixir sur une plateforme 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"
```

# Configurer des tests parallèles avec Go
<a name="sample-parallel-test-go"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle avec Go sur une plate-forme 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"
```

Dans l'exemple ci-dessus, `calculator.go` la fonction contient des fonctions mathématiques simples à tester et tous les fichiers de test se trouvent `calc` dans un dossier. `calculator.go`

# Configuration de tests parallèles avec Java (Maven)
<a name="sample-parallel-test-java-maven"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle avec Java sur une plate-forme 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"
```

Dans l'exemple donné, la variable d'environnement `CODEBUILD_CURRENT_SHARD_FILES` contient des fichiers de test dans le shard actuel, séparés par des nouvelles lignes. Ces fichiers sont convertis en une liste de noms de classes séparés par des virgules au format accepté par le `-Dtest` paramètre pour Maven.

# Configurer des tests parallèles avec Javascript (Jest)
<a name="sample-parallel-test-javascript"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle avec Javascript sur une plateforme 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'
```

# Configurer des tests parallèles avec Kotlin
<a name="sample-parallel-test-kotlin"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle avec Kotlin sur une plate-forme 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"
```

Dans l'exemple ci-dessus, la `codebuild-tests-run` CLI est utilisée deux fois. Lors de la première exécution, kotlinc compile les fichiers. La `CODEBUILD_CURRENT_SHARD_FILES` variable récupère les fichiers de test affectés à la partition actuelle, qui sont ensuite convertis en une liste séparée par des espaces. Lors de la deuxième exécution, JUnit exécute les tests. Encore une fois, `CODEBUILD_CURRENT_SHARD_FILES` récupère les fichiers de test assignés à la partition actuelle, mais cette fois ils sont convertis en noms de classes.

# Configurez des tests parallèles avec PHPUnit
<a name="sample-parallel-test-phpunit"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle PHPUnit sur une plate-forme 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'
```

# Configurer des tests parallèles avec Pytest
<a name="sample-parallel-test-python"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle avec Pytest sur une plate-forme 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"
```

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle avec Pytest sur une plate-forme 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"
```

Dans l'exemple ci-dessus, la variable d'`CODEBUILD_CURRENT_SHARD_FILES`environnement est utilisée pour récupérer les fichiers de test affectés à la partition actuelle et transmis sous forme de tableau à la commande pytest.

# Configurer des tests parallèles avec Ruby (Cucumber)
<a name="sample-parallel-test-ruby-cucumber"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests parallèles avec Cucumber sur une plate-forme 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"
```

# Configurer des tests parallèles avec Ruby (RSpec)
<a name="sample-parallel-test-ruby"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle RSpec sur une plate-forme 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"
```