« Rapport de test utilisant l'exemple AWS CLI » - AWS CodeBuild
Exécutez l'exemple de rapport de test

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 la console CodeBuild API ou la AWS CodeBuild console pour accéder aux résultats du test. Cet exemple montre comment configurer votre rapport afin que ses résultats de test soient exportés vers un compartiment S3.

Exécutez l'exemple de rapport de test

Procédez comme suit pour exécuter l'exemple de rapport de test.

Prérequis

  • 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)

    • JUnitXML(.xml)

    • NUnitXML(.xml)

    • NUnit3XML(.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 ? dans le guide de l'utilisateur Amazon S3.

  • Créez un IAM rôle et notez-leARN. Vous en avez besoin ARN lorsque vous créez votre projet de construction.

  • 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.

Étape 1 : créer un groupe de rapports

  1. Créez un fichier nommé CreateReportGroupInput.json.

  2. Créez un dossier dans votre compartiment S3 où vos résultats de test sont exportés.

  3. Copiez ce qui suit dans CreateReportGroupInput.json. Pour <bucket-name>, utilisez le nom du compartiment S3. Pour <path-to-folder>, entrez le chemin d'accès au dossier dans votre compartiment S3. 

    {
  "name": "<report-name>",
  "type": "TEST",
  "exportConfig": {
    "exportConfigType": "S3",
    "s3Destination": {
      "bucket": "<bucket-name>",
      "path": "<path-to-folder>",
      "packaging": "NONE"
    }
  }
}

  4. 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. Prenez note du ARN pour lereportGroup. 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/<report-name>",
    "name": "<report-name>",
    "type": "TEST",
    "exportConfig": {
      "exportConfigType": "S3",
      "s3Destination": {
        "bucket": "<s3-bucket-name>",
        "path": "<folder-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.

  2. Utilisez ce qui suit YAML comme modèle pour votre buildspec.yml fichier. 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 contiennent 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 
        - <enter commands to run your tests>
        
    reports:
      <report-name-or-arn>: #test file information
      files:
        - '<test-result-files>'
      base-directory: '<optional-base-directory>'
      discard-paths: false #do not remove file paths from test result files
    Note

    Au lieu d'un groupe ARN 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 deARN, 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 et Attribution des noms des groupes de rapports.

  3. Créez un fichier nommé project.json. Ce fichier contient l'entrée de la commande create-project.

  4. Copiez ce qui suit JSON dansproject.json. Pour source, entrez le type et l'emplacement du référentiel qui contient vos fichiers source. PourserviceRole, spécifiez ARN le 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": "<your-source-url>"
  },
  "artifacts": {
    "type": "NO_ARTIFACTS"
  },
  "cache": {
    "type": "NO_CACHE"
  },
  "environment": {
    "type": "LINUX_CONTAINER",
    "image": "aws/codebuild/standard:5.0",
    "computeType": "small"
  },
  "serviceRole": "arn:aws:iam::<your-aws-account-id>:role/service-role/<your-role-name>"
}

  5. 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-projectest 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

  2. Exécutez la commande suivante pour obtenir des informations sur votre build, y compris le ARN contenu de votre rapport. Pour <build-id>, spécifiez votre ID de génération. Notez le rapport ARN dans la reportArns propriété de la sortie. 

    aws codebuild batch-get-builds --ids <build-id>

  3. Exécutez la commande suivante pour obtenir des informations sur votre rapport. Pour<report-arn>, spécifiez votre rapportARN. 

    aws codebuild batch-get-reports --report-arns <report-arn>

    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": "<report-group-arn>",
      "name": "<report-group-name>",
      "created": 1573324770.154,
      "exportConfig": {
        "exportConfigType": "S3",
        "s3Destination": {
          "bucket": "<amzn-s3-demo-bucket>",
          "path": "<path-to-your-report-results>",
          "packaging": "NONE",
          "encryptionKey": "<encryption-key>"
        }
      },
      "expired": 1575916770.0,
      "truncated": false,
      "executionId": "arn:aws:codebuild:us-west-2:123456789012:build/<name-of-build-project>:2c254862-ddf6-4831-a53f-6839a73829c1",
      "type": "TEST",
      "arn": "<report-arn>",
      "testSummary": {
        "durationInNanoSeconds": 6657770,
        "total": 11,
        "statusCounts": {
          "FAILED": 3,
          "SKIPPED": 7,
          "ERROR": 0,
          "SUCCEEDED": 1,
          "UNKNOWN": 0
        }
      }
    }
  ],
  "reportsNotFound": []
}

  4. Exécutez la commande suivante pour répertorier les informations sur les cas de test de votre rapport. Pour<report-arn>, spécifiez le 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 <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": "<report-arn>",
      "prefix": "Cucumber tests for agent",
      "message": "A test message",
      "durationInNanoSeconds": 1540540,
      "testRawDataPath": "<path-to-output-report-files>"
    },
    {
      "status": "SUCCEEDED",
      "name": "Test case 2",
      "expired": 1575916770.0,
      "reportArn": "<report-arn>",
      "prefix": "Cucumber tests for agent",
      "message": "A test message",
      "durationInNanoSeconds": 1540540,
      "testRawDataPath": "<path-to-output-report-files>"
    }
  ]
}