本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 在批量构建中执行并行测试
<a name="parallel-test"></a>

您可以使用 AWS CodeBuild 在批量生成中执行 parallel 测试。并行测试执行是一种测试方法，其中多个测试用例在不同的环境、计算机或浏览器上同时运行，而不是按顺序执行。这种方法可以显著缩短总体测试执行时间并提高测试效率。在中 CodeBuild，您可以将测试拆分到多个环境中并行运行。

并行测试执行的主要优势包括：

1. **缩短执行时间**：按顺序需要数小时的测试可以在几分钟内完成。

1. **提高资源利用率**：高效地利用可用的计算资源。

1. **更早的反馈**：更快地完成测试意味着可以更快地向开发人员提供反馈。

1. **经济实惠**：从长远来看，可以节省时间和计算成本。

在实施并行测试执行时，通常会考虑两种主要方法：独立环境和多线程。虽然这两种方法都旨在实现并发测试执行，但它们在实施和有效性方面存在显著差异。独立环境会创建隔离的实例，其中每个测试套件独立运行，而多线程使用不同的线程在同一个进程空间内同时执行多个测试。

与多线程相比，独立环境的主要优势包括：

1. **隔离**：每个测试都在完全隔离的环境中运行，以防止测试之间的干扰。

1. **资源冲突**：不存在多线程中经常发生的共享资源竞争。

1. **稳定性**：不太容易出现争用条件和同步问题。

1. **更易于调试**：当测试失败时，由于每个环境都是独立的，因此更容易确定原因。

1. **状态管理**：轻松管理困扰多线程测试的共享状态问题。

1. **更好的可扩展性**：可以轻松地添加更多环境，而不会增加复杂性。

**Topics**
+ [Support in AWS CodeBuild](#parallel-test-support)
+ [在批量构建中启用并行测试执行](parallel-test-enable.md)
+ [使用 `codebuild-tests-run` CLI 命令](parallel-test-tests-run.md)
+ [使用 `codebuild-glob-search` CLI 命令](parallel-test-glob-search.md)
+ [关于测试拆分](parallel-test-splitting.md)
+ [自动合并各个构建报告](parallel-test-auto-merge.md)
+ [各种测试框架的并行测试执行示例](sample-parallel-test.md)

## Support in AWS CodeBuild
<a name="parallel-test-support"></a>

AWS CodeBuild 通过其批处理构建功能为并行测试执行提供强大的支持，该功能专为利用单独的环境执行而设计。这种实施与隔离测试环境的优点完美吻合。

**使用测试分配进行批量构建**  
CodeBuild的批量生成功能允许创建多个同时运行的构建环境。每个环境都作为一个完全独立的单元运行，有自己的计算资源、运行时环境和依赖项。通过批量构建配置，您可以指定它们需要多少个并行环境，以及如何在这些环境间分配测试。

**测试分片 CLI**  
CodeBuild 通过其 CLI 工具包括内置的测试分发机制`codebuild-tests-run`，该机制可自动将测试划分到不同的环境中。

**报告聚合**  
的实现的主要优势之一 CodeBuild是它能够无缝处理测试结果聚合。当测试在不同的环境中执行时， CodeBuild 会自动收集来自每个环境的测试报告，并将其合并成批构建级别的统一测试报告。这种整合提供了测试结果的全面视图，同时保持了并行执行的效率优势。

下图解释了 AWS CodeBuild中并行测试执行的完整概念。

![\[并行测试执行的概念图。\]](http://docs.aws.amazon.com/zh_cn/codebuild/latest/userguide/images/parallel-test.png)


# 在批量构建中启用并行测试执行
<a name="parallel-test-enable"></a>

要并行运行测试，请更新批量构建 buildspec 文件，以包含构建扇出字段和要在 `parallelism` 字段中拆分测试套件的并行构建的数量，如下所示。`parallelism` 字段指定设置多少个独立的执行程序来执行测试套件。

要在多个并行执行环境中运行测试，请将 `parallelism` 字段设置为大于零的值。在下面的示例中，设置`parallelism`为 5，表示 CodeBuild 启动五个相同的构建，并行执行测试套件的一部分。

您可以使用 [codebuild-tests-run](parallel-test-tests-run.md)CLI 命令拆分并运行测试。测试文件将被拆分，并且将在每个构建中运行测试的一部分。这减少了运行完整测试套件所花的总时间。在以下示例中，测试将分成五个部分，并根据测试的名称计算拆分点。

```
version: 0.2

batch:
  fast-fail: false 
  build-fanout:
    parallelism: 5
    ignore-failure: false
    
phases:
  install:
    commands:
      - npm install jest-junit --save-dev
  pre_build:
    commands:
      - echo 'prebuild'
  build:
    commands:
      - |
        codebuild-tests-run \
         --test-command 'npx jest --runInBand --coverage' \
         --files-search "codebuild-glob-search '**/_tests_/**/*.test.js'" \
         --sharding-strategy 'equal-distribution'

  post_build:
    commands:
      - codebuild-glob-search '**/*.xml'  
      - echo "Running post-build steps..."
      - echo "Build completed on `date`"

reports:
  test-reports:
    files:
      - '**/junit.xml'               
    base-directory: .
    discard-paths: yes           
    file-format: JUNITXML
```

如果为 build-fanout 版本配置了报告，则会分别为每个版本生成测试报告，可以在控制台中相应版本的 “**报告**” 选项卡下查看这些报告。 AWS CodeBuild 

有关如何批量执行并行测试的更多信息，请参阅[各种测试框架的并行测试执行示例](sample-parallel-test.md)。

# 使用 `codebuild-tests-run` CLI 命令
<a name="parallel-test-tests-run"></a>

AWS CodeBuild 提供将测试命令和测试文件位置作为输入的 CLI。带有这些输入的 CLI 会根据测试文件名称将测试拆分为在 `parallelism` 字段中指定的分片数量。将测试文件分配给分片由分片策略决定。

```
codebuild-tests-run \
    --files-search "codebuild-glob-search '**/__tests__/*.js'" \
    --test-command 'npx jest --runInBand --coverage' \
    --sharding-strategy 'equal-distribution'
```

下表说明了 `codebuild-tests-run` CLI 命令的字段。


| 字段名称 | Type | 必需或可选 | 定义 | 
| --- | --- | --- | --- | 
|  `test-command`  |  字符串  |  必需  |  此命令用于运行测试。  | 
|  `files-search`  |  字符串  |  必需  |  此命令给出了测试文件列表。您可以使用 AWS CodeBuild 提供的 [codebuild-glob-search](parallel-test-glob-search.md)CLI 命令或您选择的任何其他文件搜索工具。  确保 `files-search` 命令输出文件名，每个文件名用换行分隔。   | 
|  `sharding-strategy`  |  枚举  |  可选  |  有效值：`equal-distribution`（默认值）、`stability` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/codebuild/latest/userguide/parallel-test-tests-run.html) 有关更多信息，请参阅 [关于测试拆分](parallel-test-splitting.md)。  | 

`codebuild-tests-run` CLI 首先使用 `files-search` 参数中提供的命令识别测试文件列表。然后，它使用指定的分片策略确定为当前分片（环境）指定的测试文件子集。最后，测试文件的这一子集格式化为以空格分隔的列表，并在执行之前附加到在 `test-command` 参数中提供的命令的末尾。

对于不接受空格分隔列表的测试框架，`codebuild-tests-run` CLI 通过 `CODEBUILD_CURRENT_SHARD_FILES` 环境变量提供了一种灵活的替代方案。此变量包含为当前构建分片指定的测试文件路径的换行分隔列表。通过利用此环境变量，您可以轻松地适应各种测试框架要求，并适应那些期望输入格式不同于空格分隔列表的要求。此外，还可以根据测试框架的需要格式化测试文件名。以下是在 Linux 上通过 Django 框架使用 `CODEBUILD_CURRENT_SHARD_FILES` 的示例。此处，`CODEBUILD_CURRENT_SHARD_FILES` 用于获取 Django 支持的*点符号*文件路径：

```
codebuild-tests-run \
    —files-search "codebuild-glob-search '/tests/test_.py'" \
    —test-command 'python3 manage.py test $(echo "$CODEBUILD_CURRENT_SHARD_FILES" | sed -E "s/\//__/g; s/\.py$//; s/__/./g")' \
    —sharding-strategy 'equal-distribution'
```

**注意**  
请注意，`CODEBUILD_CURRENT_SHARD_FILES` 环境变量只能在 `codebuild-tests-run` CLI 的范围内使用。  
另外，如果您在测试命令内使用 `CODEBUILD_CURRENT_SHARD_FILES`，请将 `CODEBUILD_CURRENT_SHARD_FILES` 放在双引号内，如上面的示例所示。

# 使用 `codebuild-glob-search` CLI 命令
<a name="parallel-test-glob-search"></a>

AWS CodeBuild 提供了一个名为的内置 CLI 工具`codebuild-glob-search`，允许您根据一个或多个 glob 模式搜索工作目录中的文件。当您要对项目中的特定文件或目录运行测试时，此工具可能特别有用。

## 用法
<a name="parallel-test-glob-search.usage"></a>

`codebuild-glob-search` CLI 的使用语法如下：

```
codebuild-glob-search <glob_pattern1> [<glob_pattern2> ...]
```
+ `<glob_pattern1>`、`<glob_pattern2>` 等：一个或多个 glob 模式，用于与工作目录中的文件进行匹配。
+ `*`：匹配任何字符序列（路径分隔符除外）。
+ `**`：匹配任何字符序列（包括路径分隔符）。

**注意**  
确保 glob 字符串带有引号。要检查模式匹配的结果，请使用 `echo` 命令。  

```
version: 0.2

phases:
  build:
    commands:
      - echo $(codebuild-glob-search '**/__tests__/*.js')
      - codebuild-glob-search '**/__tests__/*.js' | xargs -n 1 echo
```

## Output
<a name="parallel-test-glob-search.output"></a>

CLI 将输出与所提供的 glob 模式相匹配的文件路径的换行分隔列表。返回的文件路径将是工作目录的相对路径。

如果找不到与提供的模式相匹配的文件，CLI 将输出一条消息，指出未找到任何文件。

请注意，将从搜索结果中排除由于任何给定模式而找到的目录。

## 示例
<a name="parallel-test-glob-search.example"></a>

如果只想搜索测试目录及其子目录中带有 `.js` 扩展名的文件，则可以在 `codebuild-glob-search` CLI 中使用以下命令：

```
codebuild-glob-search '**/__tests__/*.js'
```

此命令将在 `__tests__` 目录及其子目录中搜索所有带有 `.js` 扩展名的文件，如模式所示。

# 关于测试拆分
<a name="parallel-test-splitting"></a>

AWS CodeBuild的测试拆分功能可让您在多个计算实例上并行执行测试套件，从而缩短总体测试运行时间。此功能是通过 CodeBuild 项目设置中的批处理配置和 buildspec 文件中的`codebuild-tests-run`实用程序启用的。

根据指定的分片策略对测试进行拆分。 CodeBuild 提供了两种分片策略，如下所示：

平等分配  
`equal-distribution` 分片策略根据测试文件名的字母顺序将测试划分到并行构建中。这种方法首先对测试文件进行排序，然后使用基于分块的方法来分配它们，从而确保将相似的文件组合在一起进行测试。建议在处理相对较小的测试文件集时使用。虽然此方法旨在为每个分片分配大致相等数量的文件，且最大差异为 1，但它并不能保证稳定性。在后续构件中添加或移除测试文件时，现有文件的分配可能会发生变化，这可能导致在分片之间重新分配。

稳定性  
`stability` 分片策略采用一致的哈希算法在分片之间拆分测试，确保文件分配保持稳定。添加或删除新文件时，这种方法可确保现有 file-to-shard分配基本保持不变。对于大型测试套件，建议使用稳定性选项将测试均匀地分配到各个分片。该机制旨在提供近乎相等的分配，确保每个分片接收的文件数量相似，且差异最小。虽然稳定性策略不能保证理想的平等分配，但它提供了近乎相等的分配，即使在添加或移除文件时也能保持各构建之间文件分配的一致性。

要启用测试拆分，您需要在 CodeBuild 项目设置中配置批处理部分，指定所需的`parallelism`级别和其他相关参数。此外，还需要在 buildspec 文件中包含 `codebuild-tests-run` 实用程序以及相应的测试命令和拆分方法。

# 自动合并各个构建报告
<a name="parallel-test-auto-merge"></a>

在 fanout 批量生成中， AWS CodeBuild 支持将单个生成报告自动合并到合并的批次级报告中。此功能提供一个批量中所有构建的测试结果和代码覆盖的全面视图。

## 工作原理
<a name="parallel-test-auto-merge.how"></a>

执行`fanout`批量生成时，每个单独的生成都会生成[测试报告](test-reporting.md)。 CodeBuild 然后自动将来自不同版本的相同报告合并到一个统一的报告中，该报告将附加到批量生成中。这些合并报告可通过 [ BatchGetBuildBatches](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_BatchGetBuildBatches.html#CodeBuild-BatchGetBuildBatches-response-buildBatches)API 的`reportArns`字段轻松访问，也可以在控制台的 “**报告**” 选项卡中查看。这种合并功能也扩展到自动发现的报告。

合并报告是在报告组下创建的，这些[报告组](test-report-group.md)要么在 buildspec 中指定，要么由自动发现。 CodeBuild您可以直接在这些报告组下分析合并报告的趋势，从而为跨同一批量构建项目的历史构建的整体构建性能和质量指标提供宝贵的见解。

对于批次中的每个单独构建， CodeBuild 都会自动创建单独的报告组。这些报告组遵循特定的命名约定，将批量构建报告组名称与 `BuildFanoutShard<shard_number>` 后缀组合在一起，其中 `shard_number` 表示在其中创建报告组的分片编号。这种整理方式可让您跟踪和分析整合构建级别和各个构建级别的趋势，从而可以灵活地监控和评估其构建过程。

批量构建报告遵循与[各个构建报告](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_Report.html)相同的结构。**报告**选项卡中的以下关键字段特定于批量构建报告：

**批量构建报告状态**  
批量构建报告的状态遵循特定的规则，具体取决于报告类型：  
+ 测试报告：
  + 成功：当所有单独的构建报告都成功时，状态设置为成功。
  + 失败：如果任何单个构建报告失败，则状态将设置为失败。
  + 未完成：如果有任何单个构建报告缺失或状态为未完成，则状态将标记为未完成。
+ 代码覆盖率报告：
  + 完成：当所有单独的构建报告都完成时，状态设置为完成。
  + 失败：如果任何单个构建报告失败，则状态将设置为失败。
  + 未完成：如果有任何单个构建报告缺失或状态为未完成，则状态将标记为未完成。

**测试摘要**  
合并测试报告整合了所有单个构建报告中的以下字段：  
+ duration-in-nano-seconds：所有单独构建报告中的最大测试持续时间（以纳秒为单位）。
+ total：所有测试用例的总数，即每个构建中的测试总数之和。
+ status-counts：提供测试状态（例如“通过”、“失败”或“跳过”）的整合视图，这些状态是通过汇总所有单个构建中每种状态类型的计数计算得出的。

**代码覆盖摘要**  
合并的代码覆盖报告使用以下计算方法合并了所有单个构建中的字段：  
+ branches-covered：各个报告中所有覆盖的分支的总和。
+ branches-missed：各个报告中所有错过的分支的总和。
+ branch-coverage-percentage: `(Total covered branches / Total branches) * 100`
+ lines-covered：各个报告中所有覆盖的行的总和。
+ lines-missed：各个报告中所有错过的行的总和。
+ lines-coverage-percentage: `(Total covered lines / Total lines) * 100`

**执行 ID**  
批量构建 ARN。

**测试用例**  
合并后的报告包含来自各个版本的所有测试用例的合并列表，可通过 [DescribeTestCases](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_DescribeTestCases.html)API 和控制台中的批量生成报告进行访问。

**代码覆盖**  
合并后的代码覆盖率报告提供了所有单独版本中每个文件的合并行和分支覆盖率信息，可通过 [DescribeCodeCoverages](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_DescribeCodeCoverages.html)API 和控制台中的批量生成报告进行访问。注意：对于分布在不同分片上的多个测试文件所涵盖的文件，合并报告使用以下选择标准：  

1. 主要选择基于分片中最高的行覆盖率。

1. 如果多个分片上的行覆盖率相等，则会选择分支覆盖率最高的分片。

# 各种测试框架的并行测试执行示例
<a name="sample-parallel-test"></a>

您可以使用 `codebuild-tests-run` CLI 命令跨并行执行环境拆分和运行测试。下一节提供了各种框架的 `buildspec.yml` 示例，说明了 `codebuild-tests-run` 命令的用法。
+ 下面的每个示例包含的 `parallelism` 级别为五，这意味着将创建五个相同的执行环境来拆分测试。您可以通过修改 `build-fanout` 部分中的 `parallelism` 值来选择适合您项目的 `parallelism` 级别。
+ 下面的每个示例显示了将测试配置为按测试文件名进行拆分（默认情况下）。这可以跨并行执行环境均匀地分配测试。

在开始之前，请参阅[在批量构建中执行并行测试](parallel-test.md)以了解更多信息。

有关使用 `codebuild-tests-run` CLI 命令时选项的完整列表，请参阅[使用 `codebuild-tests-run` CLI 命令](parallel-test-tests-run.md)。

**Topics**
+ [使用 Django 配置并行测试](sample-parallel-test-django.md)
+ [使用 Elixir 配置并行测试](sample-parallel-test-elixir.md)
+ [使用 Go 配置并行测试](sample-parallel-test-go.md)
+ [使用 Java（Maven）配置并行测试](sample-parallel-test-java-maven.md)
+ [使用 Javascript 配置并行测试（Jest）](sample-parallel-test-javascript.md)
+ [使用 Kotlin 配置并行测试](sample-parallel-test-kotlin.md)
+ [使用 PHPUnit 配置并行测试](sample-parallel-test-phpunit.md)
+ [使用 Pytest 配置并行测试](sample-parallel-test-python.md)
+ [使用 Ruby 配置并行测试（Cucumber）](sample-parallel-test-ruby-cucumber.md)
+ [使用 Ruby 配置并行测试（RSpec）](sample-parallel-test-ruby.md)

# 使用 Django 配置并行测试
<a name="sample-parallel-test-django"></a>

以下 `buildspec.yml` 示例显示在 Ubuntu 平台上使用 Django 并行执行测试：

```
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'
```

上面的示例显示了环境变量 `CODEBUILD_CURRENT_SHARD_FILES` 的用法。此处，`CODEBUILD_CURRENT_SHARD_FILES` 用于获取 Django 支持的点符号文件路径。如上所示，在双引号内使用 `CODEBUILD_CURRENT_SHARD_FILES`。

# 使用 Elixir 配置并行测试
<a name="sample-parallel-test-elixir"></a>

以下 `buildspec.yml` 示例显示在 Ubuntu 平台上使用 Elixir 并行执行测试：

```
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"
```

# 使用 Go 配置并行测试
<a name="sample-parallel-test-go"></a>

以下 `buildspec.yml` 示例显示在 Linux 平台上使用 Go 并行执行测试：

```
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"
```

在上面的示例中，`calculator.go` 函数包含要测试的简单数学函数，并且所有测试文件和 `calculator.go` 文件都在 `calc` 文件夹中。

# 使用 Java（Maven）配置并行测试
<a name="sample-parallel-test-java-maven"></a>

以下 `buildspec.yml` 示例显示在 Linux 平台上使用 Java 并行执行测试：

```
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"
```

在给定的示例中，环境变量 `CODEBUILD_CURRENT_SHARD_FILES` 包含当前分片中的测试文件，用换行分隔。这些文件以 Maven 的 `-Dtest` 参数所接受的格式转换为以逗号分隔的类名称列表。

# 使用 Javascript 配置并行测试（Jest）
<a name="sample-parallel-test-javascript"></a>

以下 `buildspec.yml` 示例显示在 Ubuntu 平台上使用 Javascript 并行执行测试：

```
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'
```

# 使用 Kotlin 配置并行测试
<a name="sample-parallel-test-kotlin"></a>

以下 `buildspec.yml` 示例显示在 Linux 平台上使用 Kotlin 并行执行测试：

```
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"
```

在上面的示例中，使用了 `codebuild-tests-run` CLI 两次。在第一次运行期间，kotlinc 编译文件。`CODEBUILD_CURRENT_SHARD_FILES` 变量检索分配给当前分片的测试文件，然后将其转换为以空格分隔的列表。在第二次运行中，JUnit 执行测试。再次，`CODEBUILD_CURRENT_SHARD_FILES` 获取分配给当前分片的测试文件，但这次它们转换为类名称。

# 使用 PHPUnit 配置并行测试
<a name="sample-parallel-test-phpunit"></a>

以下 `buildspec.yml` 示例显示在 Linux 平台上使用 PHPUnit 并行执行测试：

```
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'
```

# 使用 Pytest 配置并行测试
<a name="sample-parallel-test-python"></a>

以下 `buildspec.yml` 示例显示在 Ubuntu 平台上使用 Pytest 并行执行测试：

```
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"
```

以下 `buildspec.yml` 示例显示在 Windows 平台上使用 Pytest 并行执行测试：

```
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"
```

在上面的示例中，`CODEBUILD_CURRENT_SHARD_FILES` 环境变量用于获取分配给当前分片并作为数组传递给 pytest 命令的测试文件。

# 使用 Ruby 配置并行测试（Cucumber）
<a name="sample-parallel-test-ruby-cucumber"></a>

以下 `buildspec.yml` 示例显示在 Linux 平台上使用 Cucumber 并行执行测试：

```
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"
```

# 使用 Ruby 配置并行测试（RSpec）
<a name="sample-parallel-test-ruby"></a>

以下 `buildspec.yml` 示例显示在 Ubuntu 平台上使用 RSpec 并行执行测试：

```
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"
```