«Rapporto di prova utilizzando il AWS CLI» campione - AWS CodeBuild
Esegui l'esempio del rapporto di prova

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

«Rapporto di prova utilizzando il AWS CLI» campione

I test specificati nel file buildspec vengono eseguiti durante la compilazione. Questo esempio mostra come utilizzare il per AWS CLI incorporare i test nelle build in CodeBuild. È possibile utilizzare JUnit per creare test unitari oppure utilizzare un altro strumento per creare test di configurazione. La successiva valutazione dei risultati dei test consentirà di risolvere eventuali problemi od ottimizzare l'applicazione.

È possibile utilizzare la console CodeBuild API o la AWS CodeBuild console per accedere ai risultati del test. In questo esempio viene illustrato come configurare il report in modo che i risultati dei test vengano esportati in un bucket S3.

Esegui l'esempio del rapporto di prova

Utilizza i seguenti passaggi per eseguire l'esempio del rapporto di prova.

Prerequisiti

  • Crea i casi di test. Questo esempio presuppone l'esistenza di casi di test da includere nel report di test esemplificativo. Ricorda di specificare la posizione dei file di test nel file buildspec.

    Sono supportati i seguenti formati di file di report di test:

    • Cetriolo JSON (.json)

    • JUnitXML(.xml)

    • NUnitXML(.xml)

    • NUnit3XML(.xml)

    • TestNg XML (.xml)

    • Visual Studio TRX (.trx)

    • Visual Studio TRX XML (.xml)

    Crea i tuoi casi di test con qualsiasi framework di test in grado di creare file di report in uno di questi formati (ad esempio, il JUnit plug-in Surefire, TestNG o Cucumber).

  • Crea un bucket S3 e annotane il nome. Per ulteriori informazioni, vedi Come posso creare un bucket S3? nella Guida per l'utente di Amazon S3.

  • Crea un IAM ruolo e prendine nota. ARN Ne hai bisogno ARN quando crei il tuo progetto di costruzione.

  • Se il ruolo non dispone delle autorizzazioni seguenti, aggiungile. 

    {
    "Effect": "Allow",
    "Resource": [
        "*"
    ],
    "Action": [
        "codebuild:CreateReportGroup",
        "codebuild:CreateReport",
        "codebuild:UpdateReport",
        "codebuild:BatchPutTestCases"
    ]
}

    Per ulteriori informazioni, consulta Autorizzazioni per le operazioni correlate ai report di test.

Fase 1: Creare un gruppo di report

  1. Crea un file denominato CreateReportGroupInput.json.

  2. Creare una cartella nel bucket S3 in cui vengano esportati i risultati dei test.

  3. Copiare quanto segue in CreateReportGroupInput.json. Per <bucket-name>, utilizzare il nome del bucket S3. Per <path-to-folder>, immettere il percorso della cartella nel bucket S3. 

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

  4. Eseguire il comando sottostante nella directory che contiene CreateReportGroupInput.json.

    aws codebuild create-report-group --cli-input-json file://CreateReportGroupInput.json

    L'output sarà simile al seguente. Prendi nota del ARN perreportGroup. per poterlo utilizzare nel momento in cui verrà creato un progetto a esso correlato.

    {
  "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
  }
}

Passo 2: Configurare un progetto con un gruppo di report

Per eseguire un report, devi prima creare un progetto di CodeBuild compilazione configurato con il tuo gruppo di report. I casi di test specificati per il gruppo di report vengono eseguiti in concomitanza di una compilazione.

  1. Creare un file buildspec denominato buildspec.yml.

  2. Usa quanto segue YAML come modello per il tuo buildspec.yml file. Bisogna includere i comandi che eseguono i test. Nella sezione reports, vanno specificati i file contenenti i risultati dei casi di test. Questi file memorizzano i risultati dei test a cui puoi accedere CodeBuild. e scadono 30 giorni dopo la creazione. Inoltre, differiscono dai file con i risultati dei casi di test non elaborati che vengono esportati in un bucket 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
    Nota

    Invece di un gruppo ARN di report esistente, puoi anche specificare un nome per un gruppo di report che non è stato creato. Se si specifica un nome anziché unARN, CodeBuild crea un gruppo di report quando esegue una build. Il nome comprenderà il nome del progetto e quello specificato nel file buildspec in questo formato: project-name-report-group-name. Per ulteriori informazioni, consulta Crea report di test e Denominazione dei gruppi di report.

  3. Crea un file denominato project.json. Tale file contiene l'input per il comando create-project.

  4. Copia quanto segue JSON inproject.json. Per source, immettere il tipo e percorso del repository contenente i file di origine. PerserviceRole, specifica ARN il ruolo che stai utilizzando. 

    {
  "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. Eseguire il comando sottostante nella directory che contiene project.json. Viene così creato un progetto denominato test-project. 

    aws codebuild create-project --cli-input-json file://project.json

Fase 3: Esecuzione e visualizzazione dei risultati di un report

In questa sezione, viene eseguita una compilazione del progetto creato in precedenza. Durante il processo di compilazione, CodeBuild crea un rapporto con i risultati dei casi di test. Il report è incluso nel gruppo di report specificato.

  1. Per avviare una build, esegui il comando seguente. test-report-projectè il nome del progetto di compilazione creato sopra. prendendo poi nota dell'ID di compilazione visualizzato nell'output. 

    aws codebuild start-build --project-name test-report-project

  2. Esegui il comando seguente per ottenere informazioni sulla tua build, incluso il ARN rapporto. Per <build-id>, specificare l'ID di compilazione. Prendi nota del rapporto ARN nella reportArns proprietà dell'output. 

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

  3. Esegui il comando seguente per ottenere dettagli sul rapporto. Per<report-arn>, specifica il tuo rapportoARN. 

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

    L'output sarà simile al seguente. Questo output di esempio mostra quanti dei test hanno avuto esito positivo, non sono riusciti, sono stati ignorati e hanno generato un errore o restituito uno stato sconosciuto.

    {
  "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. Eseguire il comando sottostante per elencare le informazioni sui casi di test del report. Per<report-arn>, specifica il contenuto ARN del tuo rapporto. Per il parametro facoltativo --filter, è possibile specificare un risultato di stato (SUCCEEDED, FAILED, SKIPPED, ERROR o UNKNOWN). 

    aws codebuild describe-test-cases \
    --report-arn <report-arn> \
    --filter status=SUCCEEDED|FAILED|SKIPPED|ERROR|UNKNOWN

    L'output sarà simile al seguente. 

    {
  "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>"
    }
  ]
}