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.
# « Rapport de test utilisant l'exemple AWS CLI »
Les tests que vous spécifiez dans votre fichier buildspec sont exécutés pendant votre génération. Cet exemple vous montre comment utiliser le AWS CLI pour intégrer des tests dans des builds in CodeBuild. Vous pouvez l'utiliser JUnit pour créer des tests unitaires, ou vous pouvez utiliser un autre outil pour créer des tests de configuration. Vous pouvez ensuite évaluer les résultats des tests pour résoudre les problèmes ou optimiser votre application.
Vous pouvez utiliser l' CodeBuild API ou la AWS CodeBuild console pour accéder aux résultats des tests. Cet exemple montre comment configurer votre rapport afin que ses résultats de test soient exportés vers un compartiment S3.
**Topics**
+ [
## Exécutez l'exemple de rapport de test
](#sample-test-report-cli-run)
## Exécutez l'exemple de rapport de test
Procédez comme suit pour exécuter l'exemple de rapport de test.
**Topics**
+ [
### Conditions préalables
](#sample-test-report-cli-prerequisites)
+ [
### Étape 1 : créer un groupe de rapports
](#sample-test-report-cli-create-report)
+ [
### Étape 2 : Configuration d'un projet avec un groupe de rapports
](#sample-test-report-cli-create-project-with-report)
+ [
### Étape 3 : Exécuter et afficher les résultats d'un rapport
](#sample-test-report-cli-run-and-view-report-results)
### Conditions préalables
+ Créez vos cas de test. Cet échantillon est rédigé en supposant que vous avez des cas de test à inclure dans votre rapport de test. Vous spécifiez l'emplacement de vos fichiers de test dans le fichier buildspec.
Les formats de fichier de rapport de test suivants sont pris en charge :
+ Concombre JSON (.json)
+ JUnit XML (.xml)
+ NUnit XML (.xml)
+ NUnit3 XML (.xml)
+ TestNG XML (.xml)
+ Visual Studio TRX (.trx)
+ Visual Studio TRX XML (.xml)
Créez vos scénarios de test avec n'importe quel framework de test capable de créer des fichiers de rapport dans l'un de ces formats (par exemple, le JUnit plugin Surefire, TestNG ou Cucumber).
+ Créez un compartiment S3 et notez son nom. Pour plus d'informations, consultez [Comment créer un compartiment S3 ?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html) dans le *guide de l'utilisateur Amazon S3*.
+ Créez un rôle IAM et notez son ARN. Vous avez besoin de l'ARN lorsque vous créez votre projet de génération.
+ Si votre rôle ne dispose pas des autorisations suivantes, ajoutez-les.
```
{
"Effect": "Allow",
"Resource": [
"*"
],
"Action": [
"codebuild:CreateReportGroup",
"codebuild:CreateReport",
"codebuild:UpdateReport",
"codebuild:BatchPutTestCases"
]
}
```
Pour de plus amples informations, veuillez consulter [Autorisations pour les opérations de rapports de test](test-permissions.md#test-permissions-related-to-reporting).
### Étape 1 : créer un groupe de rapports
1. Créez un fichier nommé `CreateReportGroupInput.json`.
1. Créez un dossier dans votre compartiment S3 où vos résultats de test sont exportés.
1. Copiez ce qui suit dans `CreateReportGroupInput.json`. Pour ``, utilisez le nom du compartiment S3. Pour ``, entrez le chemin d'accès au dossier dans votre compartiment S3.
```
{
"name": "",
"type": "TEST",
"exportConfig": {
"exportConfigType": "S3",
"s3Destination": {
"bucket": "",
"path": "",
"packaging": "NONE"
}
}
}
```
1. Exécutez la commande suivante dans le répertoire qui contient `CreateReportGroupInput.json`.
```
aws codebuild create-report-group --cli-input-json file://CreateReportGroupInput.json
```
Le résultat se présente comme suit. Notez l'ARN pour `reportGroup`. Vous l'utilisez lorsque vous créez un projet qui utilise ce groupe de rapports.
```
{
"reportGroup": {
"arn": "arn:aws:codebuild:us-west-2:123456789012:report-group/",
"name": "",
"type": "TEST",
"exportConfig": {
"exportConfigType": "S3",
"s3Destination": {
"bucket": "",
"path": "",
"packaging": "NONE",
"encryptionKey": "arn:aws:kms:us-west-2:123456789012:alias/aws/s3"
}
},
"created": 1570837165.885,
"lastModified": 1570837165.885
}
}
```
### Étape 2 : Configuration d'un projet avec un groupe de rapports
Pour exécuter un rapport, vous devez d'abord CodeBuild créer un projet de génération configuré avec votre groupe de rapports. Les cas de test spécifiés pour votre groupe de rapports sont exécutés lorsque vous exécutez une génération.
1. Créez un fichier buildspec nommé `buildspec.yml`.
1. Utilisez le YAML suivant comme modèle pour votre fichier `buildspec.yml`. Assurez-vous d'inclure les commandes qui exécutent vos tests. Dans la section `reports`, spécifiez les fichiers qui contiennent les résultats de vos cas de test. Ces fichiers stockent les résultats des tests auxquels vous pouvez accéder CodeBuild. Ils expirent 30 jours après leur création. Ces fichiers sont différents des fichiers de résultats de cas de test bruts que vous exportez vers un compartiment S3.
```
version: 0.2
phases:
install:
runtime-versions:
java: openjdk8
build:
commands:
- echo Running tests
-
reports:
: #test file information
files:
- ''
base-directory: ''
discard-paths: false #do not remove file paths from test result files
```
**Note**
Au lieu de l'ARN d'un groupe de rapports existant, vous pouvez également spécifier un nom pour un groupe de rapports qui n'a pas été créé. Si vous spécifiez un nom au lieu d'un ARN, CodeBuild crée un groupe de rapports lors de l'exécution d'une compilation. Son nom contient le nom de votre projet et le nom que vous spécifiez dans le fichier buildspec au format suivant : `project-name-report-group-name`. Pour plus d’informations, consultez [Création de rapports de test](report-create.md) et [Attribution des noms des groupes de rapports](test-report-group-naming.md).
1. Créez un fichier nommé `project.json`. Ce fichier contient l'entrée de la commande **create-project**.
1. Copiez le JSON suivant dans `project.json`. Pour `source`, entrez le type et l'emplacement du référentiel qui contient vos fichiers source. Pour `serviceRole`, spécifiez l'ARN du rôle que vous utilisez.
```
{
"name": "test-report-project",
"description": "sample-test-report-project",
"source": {
"type": "CODECOMMIT|CODEPIPELINE|GITHUB|S3|BITBUCKET|GITHUB_ENTERPRISE|NO_SOURCE",
"location": ""
},
"artifacts": {
"type": "NO_ARTIFACTS"
},
"cache": {
"type": "NO_CACHE"
},
"environment": {
"type": "LINUX_CONTAINER",
"image": "aws/codebuild/standard:5.0",
"computeType": "small"
},
"serviceRole": "arn:aws:iam:::role/service-role/"
}
```
1. Exécutez la commande suivante dans le répertoire qui contient `project.json`. Cela crée un projet nommé `test-project`.
```
aws codebuild create-project --cli-input-json file://project.json
```
### Étape 3 : Exécuter et afficher les résultats d'un rapport
Dans cette section, vous exécutez une version du projet que vous avez créé précédemment. Au cours du processus de CodeBuild création, crée un rapport contenant les résultats des scénarios de test. Le rapport est contenu dans le groupe de rapports que vous avez spécifié.
1. Pour démarrer une compilation, exécutez la commande suivante. `test-report-project`est le nom du projet de construction créé ci-dessus. Notez l'ID de génération qui apparaît dans la sortie.
```
aws codebuild start-build --project-name test-report-project
```
1. Exécutez la commande suivante pour obtenir des informations sur votre génération, y compris l'ARN de votre rapport. Pour ``, spécifiez votre ID de génération. Notez l'ARN du rapport dans la `reportArns` propriété de la sortie.
```
aws codebuild batch-get-builds --ids
```
1. Exécutez la commande suivante pour obtenir des informations sur votre rapport. Pour ``, spécifiez votre ARN de rapport.
```
aws codebuild batch-get-reports --report-arns
```
Le résultat se présente comme suit. Cet exemple de sortie indique le nombre de tests réussis, échoués, ignorés, entraînés une erreur ou renvoyant un état inconnu.
```
{
"reports": [
{
"status": "FAILED",
"reportGroupArn": "",
"name": "",
"created": 1573324770.154,
"exportConfig": {
"exportConfigType": "S3",
"s3Destination": {
"bucket": "",
"path": "",
"packaging": "NONE",
"encryptionKey": ""
}
},
"expired": 1575916770.0,
"truncated": false,
"executionId": "arn:aws:codebuild:us-west-2:123456789012:build/:2c254862-ddf6-4831-a53f-6839a73829c1",
"type": "TEST",
"arn": "",
"testSummary": {
"durationInNanoSeconds": 6657770,
"total": 11,
"statusCounts": {
"FAILED": 3,
"SKIPPED": 7,
"ERROR": 0,
"SUCCEEDED": 1,
"UNKNOWN": 0
}
}
}
],
"reportsNotFound": []
}
```
1. Exécutez la commande suivante pour répertorier les informations sur les cas de test de votre rapport. Pour ``, spécifiez l'ARN de votre rapport. Pour le paramètre facultatif `--filter`, vous pouvez spécifier un résultat d'état (`SUCCEEDED`, `FAILED`, `SKIPPED`, `ERROR` ou `UNKNOWN`).
```
aws codebuild describe-test-cases \
--report-arn \
--filter status=SUCCEEDED|FAILED|SKIPPED|ERROR|UNKNOWN
```
Le résultat se présente comme suit.
```
{
"testCases": [
{
"status": "FAILED",
"name": "Test case 1",
"expired": 1575916770.0,
"reportArn": "",
"prefix": "Cucumber tests for agent",
"message": "A test message",
"durationInNanoSeconds": 1540540,
"testRawDataPath": ""
},
{
"status": "SUCCEEDED",
"name": "Test case 2",
"expired": 1575916770.0,
"reportArn": "",
"prefix": "Cucumber tests for agent",
"message": "A test message",
"durationInNanoSeconds": 1540540,
"testRawDataPath": ""
}
]
}
```