Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Esempio di esecuzione parallela di test per vari framework di test
<a name="sample-parallel-test"></a>

Puoi usare il comando `codebuild-tests-run` CLI per dividere ed eseguire i test in ambienti di esecuzione parallela. La sezione seguente fornisce `buildspec.yml` esempi per vari framework, illustrando l'utilizzo del comando. `codebuild-tests-run`
+ Ogni esempio seguente include un `parallelism` livello di cinque, il che significa che verranno creati cinque ambienti di esecuzione identici per suddividere i test. Puoi scegliere un `parallelism` livello adatto al tuo progetto modificando il `parallelism` valore nella `build-fanout` sezione.
+ Ogni esempio seguente mostra la configurazione dei test in modo che vengano divisi in base al nome del file di test, che è quello predefinito. Questo distribuisce i test in modo uniforme negli ambienti di esecuzione parallela.

Prima di iniziare, consulta [Esegui test paralleli in build in batch](parallel-test.md) per ulteriori informazioni.

Per un elenco completo delle opzioni quando si utilizza il comando `codebuild-tests-run` CLI, vedere. [Usa il comando `codebuild-tests-run` CLI](parallel-test-tests-run.md)

**Topics**
+ [

# Configura test paralleli con Django
](sample-parallel-test-django.md)
+ [

# Configura test paralleli con Elixir
](sample-parallel-test-elixir.md)
+ [

# Configura test paralleli con Go
](sample-parallel-test-go.md)
+ [

# Configurare test paralleli con Java (Maven)
](sample-parallel-test-java-maven.md)
+ [

# Configura test paralleli con Javascript (Jest)
](sample-parallel-test-javascript.md)
+ [

# Configura test paralleli con Kotlin
](sample-parallel-test-kotlin.md)
+ [

# Configura test paralleli con PHPUnit
](sample-parallel-test-phpunit.md)
+ [

# Configura test paralleli con Pytest
](sample-parallel-test-python.md)
+ [

# Configura test paralleli con Ruby (Cucumber)
](sample-parallel-test-ruby-cucumber.md)
+ [

# Configura test paralleli con Ruby () RSpec
](sample-parallel-test-ruby.md)

# Configura test paralleli con Django
<a name="sample-parallel-test-django"></a>

Di seguito è riportato un esempio `buildspec.yml` che mostra l'esecuzione di test paralleli con Django su una piattaforma 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'esempio precedente mostra l'utilizzo della variabile `CODEBUILD_CURRENT_SHARD_FILES` di ambiente. Qui `CODEBUILD_CURRENT_SHARD_FILES` viene utilizzato per recuperare i percorsi dei file di notazione a punti supportati da Django. Usa le virgolette doppie `CODEBUILD_CURRENT_SHARD_FILES` all'interno come mostrato sopra.

# Configura test paralleli con Elixir
<a name="sample-parallel-test-elixir"></a>

Di seguito è riportato un esempio `buildspec.yml` che mostra l'esecuzione di test paralleli con Elixir su una piattaforma 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"
```

# Configura test paralleli con Go
<a name="sample-parallel-test-go"></a>

Di seguito è riportato un esempio `buildspec.yml` che mostra l'esecuzione di test paralleli con Go su una piattaforma 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"
```

Nell'esempio precedente, `calculator.go` la funzione contiene semplici funzioni matematiche da testare e tutti i file e i file di test si trovano all'interno della `calc` cartella. `calculator.go`

# Configurare test paralleli con Java (Maven)
<a name="sample-parallel-test-java-maven"></a>

Di seguito è riportato un esempio `buildspec.yml` che mostra l'esecuzione di test paralleli con Java su una piattaforma 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"
```

Nell'esempio riportato, la variabile di ambiente `CODEBUILD_CURRENT_SHARD_FILES` contiene file di test nello shard corrente, separati da nuove righe. Questi file vengono convertiti in un elenco di nomi di classi separati da virgole nel formato accettato dal parametro per Maven. `-Dtest`

# Configura test paralleli con Javascript (Jest)
<a name="sample-parallel-test-javascript"></a>

Di seguito è riportato un esempio `buildspec.yml` che mostra l'esecuzione di test paralleli con Javascript su una piattaforma 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'
```

# Configura test paralleli con Kotlin
<a name="sample-parallel-test-kotlin"></a>

Di seguito è riportato un esempio `buildspec.yml` che mostra l'esecuzione di test paralleli con Kotlin su una piattaforma 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"
```

Nell'esempio precedente, la `codebuild-tests-run` CLI viene utilizzata due volte. Durante la prima esecuzione, kotlinc compila i file. La `CODEBUILD_CURRENT_SHARD_FILES` variabile recupera i file di test assegnati allo shard corrente, che vengono poi convertiti in un elenco separato da spazi. Nella seconda esecuzione, JUnit esegue i test. Ancora una volta, `CODEBUILD_CURRENT_SHARD_FILES` recupera i file di test assegnati allo shard corrente, ma questa volta vengono convertiti in nomi di classe.

# Configura test paralleli con PHPUnit
<a name="sample-parallel-test-phpunit"></a>

Di seguito è riportato un esempio di un test `buildspec.yml` che mostra l'esecuzione di test paralleli PHPUnit su una piattaforma 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'
```

# Configura test paralleli con Pytest
<a name="sample-parallel-test-python"></a>

Di seguito è riportato un esempio `buildspec.yml` che mostra l'esecuzione di test paralleli con Pytest su una piattaforma 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"
```

Di seguito è riportato un esempio `buildspec.yml` che mostra l'esecuzione di test paralleli con Pytest su una piattaforma 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"
```

Nell'esempio precedente, la variabile di `CODEBUILD_CURRENT_SHARD_FILES` ambiente viene utilizzata per recuperare i file di test assegnati allo shard corrente e passati come array al comando pytest.

# Configura test paralleli con Ruby (Cucumber)
<a name="sample-parallel-test-ruby-cucumber"></a>

Di seguito è riportato un esempio `buildspec.yml` che mostra l'esecuzione di test paralleli con Cucumber su una piattaforma 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"
```

# Configura test paralleli con Ruby () RSpec
<a name="sample-parallel-test-ruby"></a>

Di seguito è riportato un esempio di un test `buildspec.yml` che mostra l'esecuzione di test paralleli RSpec su una piattaforma 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"
```