«Informe de prueba utilizando la AWS CLI» muestra - AWS CodeBuild
Ejecute el ejemplo del informe de prueba

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

«Informe de prueba utilizando la AWS CLI» muestra

Las pruebas que especifique en su archivo buildspec se ejecutan durante la compilación. En este ejemplo, se muestra cómo utilizarlos AWS CLI para incorporar las pruebas en las versiones integradas CodeBuild. Puede utilizarla JUnit para crear pruebas unitarias o puede utilizar otra herramienta para crear pruebas de configuración. Después, puede evaluar los resultados de las pruebas para solucionar problemas u optimizar la aplicación.

Puede usar la consola CodeBuild API o la AWS CodeBuild consola para acceder a los resultados de las pruebas. En este ejemplo se muestra cómo configurar el informe para que los resultados de las pruebas se exporten a un bucket de S3.

Ejecute el ejemplo del informe de prueba

Siga los pasos siguientes para ejecutar el ejemplo del informe de prueba.

Requisitos previos

  • Cree los casos de prueba. Esta muestra se escribe bajo el supuesto de que tiene casos de prueba para incluirlos en su informe de pruebas de muestra. Especifique la ubicación de los archivos de prueba en el archivo buildspec.

    Se admiten los siguientes formatos de archivo de informe de prueba:

    • Pepino JSON (.json)

    • JUnitXML(.xml)

    • NUnitXML(.xml)

    • NUnit3XML(.xml)

    • TestNG XML (.xml)

    • Visual Studio TRX (.trx)

    • Visual Studio TRX XML (.xml)

    Cree sus casos de prueba con cualquier marco de pruebas que pueda crear archivos de informes en uno de estos formatos (por ejemplo, el JUnit complemento Surefire, TestNG o Cucumber).

  • Cree un bucket de S3 y anote su nombre. Para obtener más información, consulte ¿Cómo puedo crear un bucket de S3? en la Guía del usuario de Amazon S3.

  • Crea un IAM rol y anota su rol. ARN Lo necesitas ARN cuando creas tu proyecto de construcción.

  • Si el rol no tiene los permisos siguientes, añádalos. 

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

    Para obtener más información, consulte Permisos para las operaciones de informes de pruebas.

Paso 1: Crear un grupo de informes

  1. Cree un archivo denominado CreateReportGroupInput.json.

  2. Cree una carpeta en el bucket de S3 donde se exportarán los resultados de las pruebas.

  3. Copie lo siguiente en CreateReportGroupInput.json. Para <bucket-name>, use el nombre del bucket de S3. Para <path-to-folder>, escriba la ruta de acceso a la carpeta en el bucket de S3. 

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

  4. Ejecute el siguiente comando en el directorio que contiene CreateReportGroupInput.json:

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

    El resultado es similar al siguiente. Anote el ARN para elreportGroup. Se utiliza al crear un proyecto que utiliza este grupo de informes.

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

Paso 2: Configurar un proyecto con un grupo de informes

Para ejecutar un informe, primero debe crear un proyecto de CodeBuild compilación que esté configurado con su grupo de informes. Los casos de prueba especificados para su grupo de informes se ejecutan cuando se ejecuta una compilación.

  1. Cree un archivo buildspec denominado buildspec.yml.

  2. Use lo siguiente YAML como plantilla para su buildspec.yml archivo. Asegúrese de incluir los comandos que ejecutan las pruebas. En la sección reports, especifique los archivos que contienen los resultados de los casos de prueba. Estos archivos almacenan los resultados de las pruebas a los que puede acceder CodeBuild. Caducan 30 días después de su creación. Estos archivos son distintos de los archivos de resultados de casos de prueba sin procesar que se exportan a un bucket de 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

    En lugar del grupo ARN de informes existente, también puede especificar un nombre para un grupo de informes que no se haya creado. Si especifica un nombre en lugar de unoARN, CodeBuild crea un grupo de informes cuando ejecuta una compilación. Su nombre contiene el nombre de proyecto y el nombre especificado en el archivo buildspec en este formato: project-name-report-group-name. Para obtener más información, consulte Cree informes de pruebas y Nomenclatura de grupos de informes.

  3. Cree un archivo denominado project.json. Este archivo contiene la entrada para el comando create-project.

  4. Copie lo siguiente JSON enproject.json. Para source, introduzca el tipo y la ubicación del repositorio que contiene los archivos de origen. ParaserviceRole, especifique ARN el rol que está utilizando. 

    {
  "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. Ejecute el siguiente comando en el directorio que contiene project.json: De este modo se crea un proyecto llamado test-project. 

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

Paso 3: Ejecute y vea los resultados de un informe

En esta sección, se ejecuta una compilación del proyecto creado anteriormente. Durante el proceso de creación, CodeBuild crea un informe con los resultados de los casos de prueba. El informe se incluye en el grupo de informes especificado.

  1. Para iniciar una compilación, ejecute el comando siguiente. test-report-project es el nombre del proyecto de compilación creado anteriormente. Anote el ID de compilación que aparece en la salida. 

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

  2. Ejecuta el siguiente comando para obtener información sobre tu compilación, incluido el ARN informe. Para <build-id>, especifique su ID de compilación. Anote el informe ARN en la reportArns propiedad de la salida. 

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

  3. Ejecute el comando siguiente para obtener detalles sobre su informe. Para<report-arn>, especifique su informeARN. 

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

    El resultado es similar al siguiente. Esta salida de muestra presenta cuántas pruebas fueron correctas, tuvieron errores, se omitieron, produjeron un error o devolvieron un estado desconocido.

    {
  "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. Ejecute el comando siguiente para enumerar la información sobre los casos de prueba para su informe. Para<report-arn>, especifique el ARN de su informe. Para el parámetro --filter opcional, puede especificar un resultado de estado (SUCCEEDED, FAILED, SKIPPED, ERROR o UNKNOWN). 

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

    El resultado es similar al siguiente. 

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