Crie um relatório de teste CodeBuild usando a AWS CLI amostra - AWS CodeBuild
Pré-requisitosCriar um grupo de relatóriosConfigurar um projeto com um grupo de relatóriosExecutar e visualizar resultados de um relatório

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Crie um relatório de teste CodeBuild usando a AWS CLI amostra

Os testes que você especificar no arquivo buildspec são executados durante a compilação. Este exemplo mostra como usar o para AWS CLI incorporar testes em CodeBuild compilações. Você pode usar JUnit para criar testes de unidade ou usar outra ferramenta para criar testes de configuração. Depois, você pode avaliar os resultados do teste para corrigir problemas ou otimizar seu aplicativo.

Você pode usar a CodeBuild API ou o AWS CodeBuild console para acessar os resultados do teste. Este exemplo mostra como configurar seu relatório para que seus resultados de teste sejam exportados para um bucket do S3.

Pré-requisitos

  • Criar seus casos de teste. Este exemplo é escrito partindo-se do pressuposto de que você tem casos de teste para incluir em seu relatório de teste de amostra. Especifique o local dos arquivos de teste no arquivo buildspec.

    Os seguintes formatos de arquivo de relatório de teste são compatíveis:

    • Cucumber JSON (.json)

    • JUnit XML (.xml)

    • NUnit XML (.xml)

    • NUnit3 XML (.xml)

    • TestNG XML (.xml)

    • Visual Studio TRX (.trx)

    Crie seus casos de teste com qualquer estrutura de trabalho de teste que possa criar arquivos de relatório em um desses formatos (por exemplo, Surefire JUnit plugin, TestNG ou Cucumber).

  • Crie um bucket do S3 e anote seu nome. Para obter mais informações, consulte How do I create an S3 bucket? no Guia do usuário do Amazon S3.

  • Crie um perfil do IAM e anote o ARN. É necessário o ARN ao criar seu projeto de compilação.

  • Se sua função não tiver as seguintes permissões, adicione-as. 

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

    Para ter mais informações, consulte Permissões para operações de relatórios de testes.

Criar um grupo de relatórios

  1. Crie um arquivo chamado CreateReportGroupInput.json.

  2. Crie uma pasta no bucket do S3 onde os resultados do teste são exportados.

  3. Copie o seguinte em CreateReportGroupInput.json. Em <bucket-name>, use o nome do bucket do S3. Em <path-to-folder>, insira o caminho para a pasta no bucket do S3. 

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

  4. Execute o comando a seguir no diretório que contenha CreateReportGroupInput.json.

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

    A saída é semelhante à seguinte. Anote o ARN do reportGroup. Use-o ao criar um projeto que use esse grupo de relatórios.

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

Configurar um projeto com um grupo de relatórios

Para executar um relatório, primeiro você cria um projeto de CodeBuild compilação configurado com seu grupo de relatórios. Os casos de teste especificados para o grupo de relatórios são executados quando você executa uma compilação.

  1. Crie um arquivo buildspec chamado buildspec.yml.

  2. Use o seguinte YAML como modelo para o seu arquivo buildspec.yml. Inclua os comandos que executam seus testes. Na seção reports, especifique os arquivos que contêm os resultados dos seus casos de teste. Esses arquivos armazenam os resultados do teste com os quais você pode acessar CodeBuild. Eles expiram 30 dias após sua criação. Esses arquivos são diferentes dos arquivos de resultado de caso de teste bruto exportados para um bucket do 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

    Em vez do ARN de um grupo de relatórios existente, você também pode especificar um nome para um grupo de relatórios que não foi criado. Se você especificar um nome em vez de um ARN, CodeBuild cria um grupo de relatórios ao executar uma compilação. O nome dele contém o nome do projeto e o nome que você especificar no arquivo buildspec, neste formato: project-name-report-group-name. Para ter mais informações, consulte Criar um relatório de teste e Nomenclatura do grupo de relatórios.

  3. Crie um arquivo chamado project.json. Este arquivo contém entrada para o comando create-project.

  4. Copie o seguinte JSON em project.json. Em source, insira o tipo e o local do repositório que contém os arquivos de origem. Em serviceRole, especifique o ARN da função que você está usando. 

    {
  "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. Execute o comando a seguir no diretório que contenha project.json. Isso cria um projeto chamado test-project. 

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

Executar e visualizar resultados de um relatório

Nesta seção, você executa uma compilação do projeto criado anteriormente. Durante o processo de criação, CodeBuild cria um relatório com os resultados dos casos de teste. O relatório está contido no grupo de relatórios especificado.

  1. Para iniciar uma compilação, execute o comando a seguir. test-report-project é o nome do projeto de compilação criado acima. Anote o ID de compilação que aparece na saída. 

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

  2. Execute o comando a seguir para obter informações sobre sua compilação, incluindo o ARN do seu relatório. Em <build-id>, especifique seu ID de compilação. Anote o ARN do relatório na propriedade reportArns da saída. 

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

  3. Execute o comando a seguir para obter detalhes sobre o relatório. Em <report-arn>, especifique o ARN do relatório. 

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

    A saída é semelhante à seguinte. Essa saída de exemplo mostra quantos testes foram bem-sucedidos, falharam, foram ignorados, resultaram em erro ou retornaram um status desconhecido.

    {
  "reports": [
    {
      "status": "FAILED",
      "reportGroupArn": "<report-group-arn>",
      "name": "<report-group-name>",
      "created": 1573324770.154,
      "exportConfig": {
        "exportConfigType": "S3",
        "s3Destination": {
          "bucket": "<your-S3-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. Execute o seguinte comando para listar informações sobre casos de teste para seu relatório. Em <report-arn>, especifique o ARN do seu relatório. No parâmetro opcional --filter, você pode especificar um resultado de status (SUCCEEDED, FAILED, SKIPPED, ERROR, ou UNKNOWN). 

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

    A saída é semelhante à seguinte. 

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