

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.

# Creación de una ejecución de prueba en Device Farm
<a name="how-to-create-test-run"></a>

Puede usar la consola Device Farm o la API de Device Farm para crear una ejecución de prueba. AWS CLI También puede utilizar un complemento admitido, como, por ejemplo, los complementos Jenkins o Gradle para Device Farm. Para obtener más información acerca de los complementos, consulte [Herramientas y complementos](aws-device-farm-tools-plugins.md). Para obtener información acerca de las ejecuciones, consulte [Ejecuciones](test-runs.md).

**Topics**
+ [Requisitos previos](#how-to-create-test-run-prerequisites)
+ [Creación de una ejecución de prueba (consola)](#how-to-create-test-run-console)
+ [Creación de una ejecución de prueba (AWS CLI)](#how-to-create-test-run-cli)
+ [Creación de una ejecución de prueba (API)](#how-to-create-test-run-api)
+ [Siguientes pasos](#how-to-create-test-run-console-next-steps)

## Requisitos previos
<a name="how-to-create-test-run-prerequisites"></a>

Debe tener un proyecto en Device Farm. Siga las instrucciones de [Creación de un proyecto en AWS Device Farm](how-to-create-project.md) y, a continuación, vuelva a esta página.

## Creación de una ejecución de prueba (consola)
<a name="how-to-create-test-run-console"></a>

1. Inicie sesión en la consola de Device Farm en [https://console.aws.amazon.com/devicefarm.](https://console.aws.amazon.com/devicefarm)

1. En el panel de navegación, seleccione **Pruebas de dispositivos móviles** y, a continuación, seleccione **Proyectos**.

1. Si ya dispone de un proyecto, puede cargar las pruebas en él. En caso contrario, seleccione **Nuevo proyecto**, indique un **Nombre del proyecto** y seleccione **Crear**.

1. Abra el proyecto y, a continuación, seleccione **Crear ejecución**.

1. (Opcional) En **Configuración de ejecución**, en la sección **Nombre de ejecución**, escriba un nombre para la ejecución. Si no se proporciona ningún nombre, la consola de Device Farm asignará a la ejecución el nombre “My Device Farm run” de forma predeterminada.

1. (Opcional) En **Configuración de ejecución**, en la sección **Tiempo de espera del trabajo**, puede especificar el tiempo de espera de la ejecución de la prueba. Si utiliza un número ilimitado de ranuras de prueba, confirme que **Sin medidor** esté seleccionado en **Método de facturación**.

1. En **Configuración de ejecución**, en la sección **Tipo de ejecución**, seleccione el tipo de ejecución. Seleccione **Aplicación Android** si no tiene ninguna aplicación lista para probarla o si está probando una aplicación en Android (.apk). Seleccione **Aplicación iOS** si está probando una aplicación iOS (.ipa). Seleccione **Aplicación web** si desea probar aplicaciones web.

1. En **Seleccionar aplicación**, en la sección **Opciones de selección de aplicaciones**, elija **Seleccionar aplicación de muestra proporcionada por Device Farm** si no tiene ninguna aplicación disponible para probarla. Si va a traer su propia aplicación, seleccione **Cargar aplicación propia** y elija el archivo de su aplicación. Si carga una aplicación iOS, asegúrese de elegir **Dispositivo iOS**, en lugar de un simulador.

1. En **Configurar prueba**, seleccione uno de los marcos de prueba disponibles.
**nota**  
Si no hay ninguna prueba disponible, elija **Integrado: fuzzing** para ejecutar un conjunto de pruebas integrado estándar. Si elige **Integrado: fuzzing** y aparecen los cuadros **Recuento de eventos**, **Acelerador de eventos** y **Semilla aleatorizadora**, puede cambiar los valores o conservarlos. 

   Para obtener más información acerca de los conjuntos de pruebas disponibles, consulte [Marcos de pruebas y pruebas integradas en AWS Device Farm](test-types.md).

1. Si no ha elegido **Integrado: fuzzing**, seleccione **Elegir archivo** en **Seleccionar paquete de prueba**. Busque y elija el archivo que contiene las pruebas.

1. Para su entorno de prueba, seleccione **Ejecutar la prueba en nuestro entorno estándar** o **Ejecutar la prueba en un entorno personalizado**. Para obtener más información, consulte [Entornos de prueba de AWS Device Farm](test-environments.md).

1. Si está utilizando un entorno de pruebas personalizado, también puede hacer lo siguiente:
   + Si desea editar la especificación de prueba predeterminada en un entorno de pruebas personalizado, seleccione **Editar** para actualizar la especificación YAML predeterminada.
   + Si ha modificado la especificación de prueba, seleccione **Guardar como nuevo** para actualizarla.
   + Puede configurar las variables de entorno. Las variables que se proporcionan aquí tendrán prioridad sobre las que se puedan configurar en el proyecto principal.

1. En **Seleccionar dispositivos**, realice una de las siguientes acciones:
   + Para elegir un grupo de dispositivos integrados donde ejecutar las pruebas, en **Grupo de dispositivos**, elija **Dispositivos principales**. 
   + Para crear su propio grupo de dispositivos donde ejecutar las pruebas, siga las instrucciones de [Creación de un grupo de dispositivos](how-to-create-device-pool.md) y, a continuación, regrese a esta página.
   + Si ha creado su propio grupo de dispositivos antes, en **Grupo de dispositivos**, elija su grupo de dispositivos. 
   + Elija **Seleccionar dispositivos manualmente** y, a continuación, los dispositivos deseados en los que los desea ejecutar. Esta configuración no se guardará.

   Para obtener más información, consulte [Compatibilidad de dispositivos en AWS Device Farmdispositivos](devices.md).

1. (Opcional) Para añadir una configuración adicional, abra el menú desplegable **Configuración adicional**. En esta sección, puede hacer una de las siguientes acciones:
   + Para proporcionar un ARN de rol de ejecución o anular uno configurado en el proyecto principal, utilice el campo ARN del rol de ejecución.
   + Para proporcionar otros datos para que Device Farm los utilice durante la ejecución, junto a **Agregar datos adicionales**, **seleccione Elegir archivo** y, a continuación, busque el archivo .zip que contiene los datos.
   + Para instalar una aplicación adicional que Device Farm utilizará durante la ejecución, junto a **Instalar otras aplicaciones**, seleccione **Elegir archivo** y, a continuación, busque y seleccione el archivo .apk o .ipa que contiene la aplicación. Repita la acción para las demás aplicaciones que desee instalar. Puede cambiar el orden de instalación arrastrando y soltando las aplicaciones después de cargarlas. 
   + Para especificar si las opciones de wifi, Bluetooth, GPS o NFC estarán habilitadas durante la ejecución, junto a **Definir estados de radio**, seleccione las casillas correspondientes.
   + Para preestablecer la latitud y la longitud del dispositivo para la ejecución, junto a **Ubicación del dispositivo**, escriba las coordenadas.
   + Para preestablecer la configuración regional del dispositivo para la ejecución, seleccione la configuración regional en **Configuración regional del dispositivo**.
   + Seleccione **Habilitar grabación de video** para grabar video durante la prueba.
   + Seleccione **Habilitar la captura de datos de rendimiento de aplicaciones** para capturar datos de desempeño en el dispositivo.
**nota**  
Por el momento, la configuración del estado de radio y la configuración regional del dispositivo solo está disponible en pruebas nativas de Android.
**nota**  
Si tiene dispositivos privados, también se muestra la opción Configuración específica para dispositivos privados.

1. En la parte inferior de la página, elija **Crear ejecución** para programar la ejecución.

Device Farm comenzará la ejecución tan pronto como los dispositivos estén disponibles, normalmente en unos minutos. Durante la ejecución de la prueba, la consola de Device Farm mostrará un icono pendiente ![\[Device Farm scheduled a job.\]](http://docs.aws.amazon.com/es_es/devicefarm/latest/developerguide/images/df-run-calendar.png) en la tabla de ejecución. Cada dispositivo en ejecución también empezará con el icono de pendiente y, después, pasará al icono de ejecución ![\[Device Farm progress indicator.\]](http://docs.aws.amazon.com/es_es/devicefarm/latest/developerguide/images/df-run-progress.png) cuando comience la prueba. Al finalizar cada prueba, aparece un icono con el resultado de la prueba junto al nombre del dispositivo. Cuando se hayan completado todas las pruebas, el icono de pendiente situado junto a la ejecución pasará a ser el icono del resultado de la prueba.

Si necesita detener la ejecución de prueba, consulte [Detención de una ejecución en AWS Device Farm](how-to-stop-test-runs.md).

## Creación de una ejecución de prueba (AWS CLI)
<a name="how-to-create-test-run-cli"></a>

Puede usarlo para crear una ejecución de prueba AWS CLI .

**Topics**
+ [Paso 1: Elegir un proyecto](#how-to-create-test-run-cli-step1)
+ [Paso 2: Elegir un grupo de dispositivos](#how-to-create-test-run-cli-step2)
+ [Paso 3: Cargar el archivo de la aplicación](#how-to-create-test-run-cli-step3)
+ [Paso 4: Cargar el paquete de scripts de pruebas](#how-to-create-test-run-cli-step4)
+ [Paso 5: Cargar la especificación de prueba personalizada (opcional)](#how-to-create-test-run-cli-step5)
+ [Paso 6: Programar una ejecución de prueba](#how-to-create-test-run-cli-step6)

### Paso 1: Elegir un proyecto
<a name="how-to-create-test-run-cli-step1"></a>

Debe asociar la ejecución de prueba a un proyecto de Device Farm.

1. Para ver una lista de sus proyectos de Device Farm, ejecute **list-projects**. Si no dispone de ningún proyecto, consulte [Creación de un proyecto en AWS Device Farm](how-to-create-project.md).

   Ejemplo:

   ```
   aws devicefarm list-projects
   ```

   La respuesta incluye una lista de proyectos de Device Farm.

   ```
   {
       "projects": [
           {
               "name": "MyProject",
               "arn": "arn:aws:devicefarm:us-west-2:123456789101:project:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
               "created": 1503612890.057
           }
       ]
   }
   ```

1. Seleccione un proyecto para asociarlo a la ejecución de prueba y anote su nombre de recurso de Amazon (ARN).

### Paso 2: Elegir un grupo de dispositivos
<a name="how-to-create-test-run-cli-step2"></a>

Debe elegir un grupo de dispositivos para asociárselo a la ejecución de prueba.

1. Para ver los grupos de dispositivos, ejecute **list-device-pools** especificando el ARN del proyecto.

   Ejemplo:

   ```
   aws devicefarm list-device-pools --arn arn:MyProjectARN
   ```

   La respuesta incluye los grupos de dispositivos integrados de Device Farm, tales como **Top Devices**, así como todos los grupos de dispositivos creados previamente para este proyecto:

   ```
   {
       "devicePools": [
           {
               "rules": [
                   {
                       "attribute": "ARN",
                       "operator": "IN",
                       "value": "[\"arn:aws:devicefarm:us-west-2::device:example1\",\"arn:aws:devicefarm:us-west-2::device:example2\",\"arn:aws:devicefarm:us-west-2::device:example3\"]"
                   }
               ],
               "type": "CURATED",
               "name": "Top Devices",
               "arn": "arn:aws:devicefarm:us-west-2::devicepool:example",
               "description": "Top devices"
           },
           {
               "rules": [
                   {
                       "attribute": "PLATFORM",
                       "operator": "EQUALS",
                       "value": "\"ANDROID\""
                   }
               ],
               "type": "PRIVATE",
               "name": "MyAndroidDevices",
               "arn": "arn:aws:devicefarm:us-west-2:605403973111:devicepool:example2"
           }
       ]
   }
   ```

1. Elija un grupo de dispositivos y anote su ARN.

   También puede crear un grupo de dispositivos y, a continuación, volver a este paso. Para obtener más información, consulte [Crear un grupo de dispositivos (AWS CLI)](how-to-create-device-pool.md#how-to-create-device-pool-cli).

### Paso 3: Cargar el archivo de la aplicación
<a name="how-to-create-test-run-cli-step3"></a>

Para crear la solicitud de carga y obtener una URL de carga prefirmada de Amazon Simple Storage Service (Amazon S3), necesita lo siguiente:
+ El ARN de su proyecto.
+ El nombre del archivo de aplicación.
+ El tipo de carga.

Para obtener más información, consulte [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/create-upload.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/create-upload.html).

1. Para cargar un archivo, ejecute **create-upload** con los parámetros `–-project-arn`, `--name` y `--type`.

   En este ejemplo se crea una carga para una aplicación Android:

   ```
   aws devicefarm create-upload -–project-arn arn:MyProjectArn -–name MyAndroid.apk -–type ANDROID_APP
   ```

   La respuesta incluye el ARN de carga de la aplicación y una URL prefirmada.

   ```
   {
       "upload": {
           "status": "INITIALIZED",
           "name": "MyAndroid.apk",
           "created": 1535732625.964,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL",
           "type": "ANDROID_APP",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
       }
   }
   ```

1. Anote el ARN de carga de la aplicación y la URL prefirmada.

1. Cargar el archivo de la aplicación mediante la URL prefirmada de Amazon S3. En este ejemplo se utiliza **curl** para cargar un archivo .apk de Android:

   ```
   curl -T MyAndroid.apk "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL"
   ```

   Para obtener más información, consulte [Carga de objetos mediante prefirmado URLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/PresignedUrlUploadObject.html) en la Guía del *usuario de Amazon Simple Storage Service*.

1. Para comprobar el estado de la carga de la aplicación, ejecute **get-upload** y especifique el ARN de carga de la aplicación.

   ```
   aws devicefarm get-upload –-arn arn:MyAppUploadARN
   ```

   Espere hasta que el estado contenido en la respuesta sea **SUCCEEDED** antes de cargar el paquete de scripts de pruebas.

   ```
   {
       "upload": {
           "status": "SUCCEEDED",
           "name": "MyAndroid.apk",
           "created": 1535732625.964,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL", 
           "type": "ANDROID_APP",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
           "metadata": "{"valid": true}"
       }
   }
   ```

### Paso 4: Cargar el paquete de scripts de pruebas
<a name="how-to-create-test-run-cli-step4"></a>

A continuación, cargue el paquete de scripts de pruebas.

1. Para crear la solicitud de carga y obtener una URL de carga prefirmada de Amazon S3, ejecute **create-upload** con los parámetros `–-project-arn`, `--name` y `--type`.

   En este ejemplo se crea una carga de paquete de pruebas de Appium Java TestNG:

   ```
   aws devicefarm create-upload –-project-arn arn:MyProjectARN -–name MyTests.zip –-type APPIUM_JAVA_TESTNG_TEST_PACKAGE
   ```

   La respuesta incluye el ARN de carga del paquete de pruebas y una URL prefirmada.

   ```
   {
       "upload": {
           "status": "INITIALIZED",
           "name": "MyTests.zip",
           "created": 1535738627.195,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL",
           "type": "APPIUM_JAVA_TESTNG_TEST_PACKAGE",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
       }    
   }
   ```

1. Anote el ARN de carga del paquete de pruebas y la URL prefirmada.

1. Cargue el archivo del paquete de scripts de pruebas mediante la URL prefirmada de Amazon S3. En este ejemplo se utiliza **curl** para cargar un archivo comprimido de scripts de Appium TestNG:

   ```
   curl -T MyTests.zip "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL"
   ```

1. Para comprobar el estado de la carga del paquete de scripts de pruebas, ejecute **get-upload** y especifique el ARN de carga del paquete de pruebas del paso 1.

   ```
   aws devicefarm get-upload –-arn arn:MyTestsUploadARN
   ```

   Espere a que el estado contenido en la respuesta sea **SUCCEEDED** antes de continuar al paso siguiente, que es opcional.

   ```
   {
       "upload": {
           "status": "SUCCEEDED",
           "name": "MyTests.zip",
           "created": 1535738627.195,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL", 
           "type": "APPIUM_JAVA_TESTNG_TEST_PACKAGE",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
           "metadata": "{"valid": true}"
       }
   }
   ```

### Paso 5: Cargar la especificación de prueba personalizada (opcional)
<a name="how-to-create-test-run-cli-step5"></a>

Si utiliza las pruebas en un entorno de pruebas estándar, omita este paso.

Device Farm mantiene un archivo de especificación de prueba predeterminado para cada tipo de prueba admitido. A continuación, descargue la especificación de prueba predeterminada y utilícela para crear una carga de especificación de prueba personalizada con el fin de ejecutar las pruebas en un entorno de pruebas personalizado. Para obtener más información, consulte [Entornos de prueba de AWS Device Farm](test-environments.md).

1. Para encontrar el ARN de carga de la especificación de prueba predeterminada, ejecute **list-uploads** y especifique el ARN del proyecto.

   ```
   aws devicefarm list-uploads --arn arn:MyProjectARN
   ```

   La respuesta contiene una entrada para cada especificación de prueba predeterminada:

   ```
   {
       "uploads": [
           {
   
               {
                   "status": "SUCCEEDED",
                   "name": "Default TestSpec for Android Appium Java TestNG",
                   "created": 1529498177.474,
                   "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL", 
                   "type": "APPIUM_JAVA_TESTNG_TEST_SPEC",
                   "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
               }
           }
       ]
   }
   ```

1. Seleccione la especificación de prueba predeterminada de la lista. Anote su ARN de carga.

1. Para descargar la especificación de prueba predeterminada, ejecute **get-upload** y especifique el ARN de carga.

   Ejemplo:

   ```
   aws devicefarm get-upload –-arn arn:MyDefaultTestSpecARN
   ```

   La respuesta contiene una URL prefirmada en la que podrá descargar la especificación de prueba predeterminada.

1. En este ejemplo se utiliza **curl** para descargar la especificación de prueba predeterminada y guardarla como `MyTestSpec.yml`:

   ```
   curl "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL" > MyTestSpec.yml
   ```

1. Puede editar la especificación de prueba predeterminada de tal forma que satisfaga sus requisitos de pruebas y, a continuación, utilizar la especificación de prueba modificada en futuras ejecuciones de prueba. Omita este paso si desea usar la especificación de prueba predeterminada tal cual en un entorno de pruebas personalizado. 

1. Para crear una carga de la especificación de prueba personalizada, ejecute **create-upload** especificando el nombre de la especificación de prueba, su tipo y el ARN del proyecto.

   En este ejemplo se crea una carga para una especificación de prueba personalizada de Appium Java TestNG:

   ```
   aws devicefarm create-upload --name MyTestSpec.yml --type APPIUM_JAVA_TESTNG_TEST_SPEC --project-arn arn:MyProjectARN
   ```

   La respuesta incluye el ARN de carga de la especificación de prueba y la URL prefirmada:

   ```
   {
       "upload": {
           "status": "INITIALIZED",
           "category": "PRIVATE",
           "name": "MyTestSpec.yml",
           "created": 1535751101.221,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL", 
           "type": "APPIUM_JAVA_TESTNG_TEST_SPEC",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
       }
   }
   ```

1. Anote el ARN de carga de la especificación de prueba y la URL prefirmada.

1. Cargue el archivo de la especificación de prueba mediante la URL prefirmada de Amazon S3. En este ejemplo, se utiliza **curl** para cargar una especificación de prueba de Appium NG JavaTest:

   ```
   curl -T MyTestSpec.yml "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL"
   ```

1. Para comprobar el estado de la carga de la especificación de prueba, ejecute **get-upload** y especifique el ARN de carga.

   ```
   aws devicefarm get-upload –-arn arn:MyTestSpecUploadARN
   ```

   Espere hasta que el estado contenido en la respuesta sea **SUCCEEDED** antes de programar la ejecución de prueba.

   ```
   {
       "upload": {
           "status": "SUCCEEDED",
           "name": "MyTestSpec.yml",
           "created": 1535732625.964,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL", 
           "type": "APPIUM_JAVA_TESTNG_TEST_SPEC",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
           "metadata": "{"valid": true}"
       }
   }
   ```

   Para actualizar la especificación de prueba personalizada, ejecute **update-upload** especificando el ARN de carga de la especificación de prueba. Para obtener más información, consulte [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/update-upload.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/update-upload.html).

### Paso 6: Programar una ejecución de prueba
<a name="how-to-create-test-run-cli-step6"></a>

Para programar una ejecución de prueba con AWS CLI, ejecute**schedule-run**, especificando:
+ El ARN del proyecto del [paso 1](#how-to-create-test-run-cli-step1).
+ El ARN del grupo de dispositivos del [paso 2](#how-to-create-test-run-cli-step2).
+ El ARN de carga de la aplicación del [paso 3](#how-to-create-test-run-cli-step3).
+ El ARN de carga del paquete de prueba del [paso 4](#how-to-create-test-run-cli-step4).

 Si ejecuta las pruebas en un entorno de pruebas personalizado, también necesita el ARN de la especificación de prueba del [paso 5](#how-to-create-test-run-cli-step5).

**Para programar una ejecución en un entorno de pruebas estándar**
+ Ejecute **schedule-run** especificando el ARN del proyecto, el ARN del grupo de dispositivos, el ARN de carga de la aplicación y la información del paquete de pruebas.

  Ejemplo:

  ```
  aws devicefarm schedule-run --project-arn arn:MyProjectARN --app-arn arn:MyAppUploadARN --device-pool-arn arn:MyDevicePoolARN --name MyTestRun --test type=APPIUM_JAVA_TESTNG,testPackageArn=arn:MyTestPackageARN
  ```

  La respuesta contiene un ARN de ejecución que puede utilizar para comprobar el estado de la ejecución de prueba.

  ```
  {
      "run": {
          "status": "SCHEDULING",
          "appUpload": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345appEXAMPLE",
          "name": "MyTestRun",
          "radios": {
              "gps": true,
              "wifi": true,
              "nfc": true,
              "bluetooth": true
          },
          "created": 1535756712.946,
          "totalJobs": 179,
          "completedJobs": 0,
          "platform": "ANDROID_APP",
          "result": "PENDING",
          "devicePoolArn": "arn:aws:devicefarm:us-west-2:123456789101:devicepool:5e01a8c7-c861-4c0a-b1d5-12345devicepoolEXAMPLE",
          "jobTimeoutMinutes": 150,
          "billingMethod": "METERED",
          "type": "APPIUM_JAVA_TESTNG",
          "testSpecArn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345specEXAMPLE",
          "arn": "arn:aws:devicefarm:us-west-2:123456789101:run:5e01a8c7-c861-4c0a-b1d5-12345runEXAMPLE",
          "counters": {
              "skipped": 0,
              "warned": 0,
              "failed": 0,
              "stopped": 0,
              "passed": 0,
              "errored": 0,
              "total": 0
          }
      }
  }
  ```

  Para obtener más información, consulte [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/schedule-run.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/schedule-run.html).

**Para programar una ejecución en un entorno de pruebas personalizado**
+ Los pasos son prácticamente los mismos que para el entorno de pruebas estándar, pero se incluye un atributo `testSpecArn` adicional incluido en el parámetro `--test`.

  Ejemplo:

  ```
  aws devicefarm schedule-run --project-arn arn:MyProjectARN --app-arn arn:MyAppUploadARN --device-pool-arn arn:MyDevicePoolARN --name MyTestRun --test testSpecArn=arn:MyTestSpecUploadARN,type=APPIUM_JAVA_TESTNG,testPackageArn=arn:MyTestPackageARN
  ```

**Para comprobar el estado de la ejecución de prueba**
+ Utilice el comando **get-run** y especifique el ARN de la ejecución:

  ```
  aws devicefarm get-run --arn arn:aws:devicefarm:us-west-2:111122223333:run:5e01a8c7-c861-4c0a-b1d5-12345runEXAMPLE
  ```

Para obtener más información, consulte [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/get-run.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/get-run.html). Para obtener información sobre el uso de Device Farm con AWS CLI, consulte[AWS CLIReferencia de ](cli-ref.md).

## Creación de una ejecución de prueba (API)
<a name="how-to-create-test-run-api"></a>

Los pasos son los mismos que los descritos en la AWS CLI sección. Consulte [Creación de una ejecución de prueba (AWS CLI)](#how-to-create-test-run-cli).

Para llamar a la API [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ScheduleRun.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ScheduleRun.html), se requiere la información siguiente:
+ Un ARN de proyecto. Consulte [Crear un proyecto (API)](how-to-create-project.md#how-to-create-project-api) y [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateProject.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateProject.html).
+ Un ARN de carga de una aplicación. Consulte [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html).
+ Un ARN de carga de paquete de pruebas. Consulte [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html).
+ Un ARN de grupos de dispositivos. Consulte [Creación de un grupo de dispositivos](how-to-create-device-pool.md) y [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html).

**nota**  
Si ejecuta las pruebas en un entorno de pruebas personalizado, también necesita el ARN de carga de la especificación de prueba. Para obtener más información, consulte [Paso 5: Cargar la especificación de prueba personalizada (opcional)](#how-to-create-test-run-cli-step5) y [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html).

Para obtener más información acerca del uso de la API de Device Farm, consulte [Automatización de Device Farm](api-ref.md).

## Siguientes pasos
<a name="how-to-create-test-run-console-next-steps"></a>

En la consola de Device Farm, el icono de reloj ![\[Device Farm scheduled a job.\]](http://docs.aws.amazon.com/es_es/devicefarm/latest/developerguide/images/df-run-calendar.png) se convertirá en un icono de resultado, como el icono de ejecución correcta ![\[The test succeeded.\]](http://docs.aws.amazon.com/es_es/devicefarm/latest/developerguide/images/df-run-success.png), cuando se complete la ejecución. Tan pronto como se completan las pruebas, aparece un informe de la ejecución. Para obtener más información, consulte [Informes en AWS Device FarmInformes](reports.md).

Para usar el informe, siga las instrucciones que se indican en [Visualización de informes de pruebas en Device Farm](how-to-use-reports.md).