Requisitos previos Creación de una ejecución de prueba (consola)Creación de una ejecución de prueba (AWS CLI)Creación de una ejecución de prueba (API)Siguientes pasos

Crear una ejecución de prueba en Device Farm

Puede usar la consola Device Farm o Device Farm API 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. Para obtener información acerca de las ejecuciones, consulte Ejecuciones.

Temas

Requisitos previos
Creación de una ejecución de prueba (consola)
Creación de una ejecución de prueba (AWS CLI)
Creación de una ejecución de prueba (API)
Siguientes pasos

Requisitos previos

Debe tener un proyecto en Device Farm. Siga las instrucciones de Crear un proyecto en AWS Device Farm y, a continuación, vuelva a esta página.

Creación de una ejecución de prueba (consola)

Inicie sesión en la consola de Device Farm en https://console.aws.amazon.com/devicefarm.
En el panel de navegación, seleccione Pruebas de dispositivos móviles y, a continuación, seleccione Proyectos.
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.
Abra el proyecto y, a continuación, seleccione Crear una nueva ejecución.
En la página Elija su aplicación, seleccione Aplicación móvil o Aplicación web.
Cargue el archivo de la aplicación. También puede arrastrar y soltar el archivo o elegir una carga reciente. Si carga una aplicación iOS, asegúrese de elegir Dispositivo iOS, en lugar de un simulador.
(Opcional) En Nombre de la ejecución, escriba un nombre. De forma predeterminada, Device Farm usa el nombre del archivo de la aplicación.
Seleccione Siguiente.
En la página Configurar, elija uno de los conjuntos de pruebas 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 como están.

Para obtener más información acerca de los conjuntos de pruebas disponibles, consulte Trabajar con tipos de pruebas en AWS Device Farm.
Si no ha seleccionado Integrado: fuzzing, seleccione Elegir archivo. A continuación, busque y seleccione el archivo que contiene las pruebas.
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.
Si utiliza el entorno de pruebas estándar, vaya directamente al paso 13. Si utilizas un entorno de pruebas personalizado con el YAML archivo de especificaciones de prueba predeterminado, continúa con el paso 13.
1. Si desea editar la especificación de prueba predeterminada en un entorno de prueba personalizado, elija Editar para actualizar la especificación predeterminadaYAML.
2. Si ha modificado la especificación de prueba, seleccione Guardar como nuevo para actualizarla.
Si desea configurar las opciones de grabación de video o captura de datos de desempeño, elija Configuración avanzada.
1. Seleccione Habilitar grabación de video para grabar video durante la prueba.
2. Seleccione Habilitar la captura de datos de rendimiento de aplicaciones para capturar datos de desempeño en el dispositivo.
nota
Si tiene dispositivos privados, se muestra también la opción Configuración específica para dispositivos privados.
Seleccione Siguiente.
En la página Seleccionar dispositivos, realice una de las siguientes opciones:
- 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 Crear un grupo de dispositivos 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.
Para obtener más información, consulte Soporte de dispositivos en AWS Device Farm.
Seleccione Siguiente.
En la página Especificar el estado del dispositivo:
- 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 Wi-FiGPS, Bluetooth o NFC están activados durante la ejecución, junto a Configurar estados de radio, selecciona 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 Siguiente.
Cuando llega a Revisar e iniciar ejecución, puede especificar el tiempo de espera de ejecución de la prueba. Si utiliza un número ilimitado de ranuras de pruebas, confirme que la opción Ejecutar en ranuras no contabilizadas esté seleccionada.
Escriba un valor o utilice la barra del control deslizante para modificar el tiempo de espera de la ejecución. Para obtener más información, consulte Establezca el tiempo de espera de ejecución para las pruebas en AWS Device Farm.
Seleccione Confirmar e iniciar 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 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. 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 Detén una carrera en AWS Device Farm.

Creación de una ejecución de prueba (AWS CLI)

Puedes usar el AWS CLI para crear una ejecución de prueba.

Temas

Paso 1: Elegir un proyecto
Paso 2: Elegir un grupo de dispositivos
Paso 3: Cargar el archivo de la aplicación
Paso 4: Cargar el paquete de scripts de pruebas
Paso 5: Cargar la especificación de prueba personalizada (opcional)
Paso 6: Programar una ejecución de prueba

Paso 1: Elegir un proyecto

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

Para ver una lista de sus proyectos de Device Farm, ejecute list-projects. Si no dispone de ningún proyecto, consulte Crear un proyecto en AWS Device Farm.

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

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

Paso 2: Elegir un grupo de dispositivos

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

Para ver sus grupos de dispositivoslist-device-pools, ejecute y especifique su proyectoARN.

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

Elija un grupo de dispositivos y anote su contenidoARN.

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

Paso 3: Cargar el archivo de la aplicación

Para crear tu solicitud de carga y obtener una URL carga prefirmada del Amazon Simple Storage Service (Amazon S3), necesitas:

Tu proyectoARN.
El nombre del archivo de aplicación.
El tipo de carga.

Para obtener más información, consulte create-upload.

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 la carga de la aplicación ARN y una prefirmadaURL.


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

Anota la aplicación cargada ARN y la URL prefirmada.
Cargue el archivo de su aplicación con el Amazon S3 prefirmadoURL. 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 en la Guía del usuario de Amazon Simple Storage Service.

Para comprobar el estado de la carga de la aplicación, ejecute get-upload y especifique el estado ARN de la 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 continuación, cargue el paquete de scripts de pruebas.

Para crear su solicitud de carga y obtener una carga prefirmada de Amazon S3URL, ejecute create-upload los --type parámetros –-project-arn--name, y.

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 la carga del paquete de prueba ARN y un paquete URL prefirmado.


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

Anote el paquete ARN de prueba cargado y el URL prefirmado.
Cargue el archivo del paquete de scripts de prueba con la tarjeta prefirmada URL 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"
```

Para comprobar el estado de la carga del paquete de scripts de prueba, ejecute get-upload y especifique el estado ARN de carga del paquete de prueba desde el 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)

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.

Para encontrar la carga ARN de tu especificación de prueba predeterminada, ejecuta list-uploads y especifica tu proyectoARN.


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

Seleccione la especificación de prueba predeterminada de la lista. Toma nota de su subidaARN.
Para descargar la especificación de prueba predeterminada, ejecute get-upload y especifique la cargaARN.

Ejemplo:
```
aws devicefarm get-upload –-arn arn:MyDefaultTestSpecARN
```
La respuesta contiene una especificación prefirmada en la URL que puede descargar la especificación de prueba predeterminada.
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
```
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.

Para crear una carga de tu especificación de prueba personalizada, ejecuta y especifica el nombre de la especificación de pruebacreate-upload, el tipo de especificación de prueba y el proyecto. ARN

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 la carga y la prefirma de las especificaciones de la prueba: ARN URL


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

Para la prueba, anote ARN las especificaciones subidas y las prefirmadas. URL
Cargue el archivo de especificaciones de la prueba con el Amazon S3 URL prefirmado. 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"
```

Para comprobar el estado de la carga de las especificaciones de prueba, ejecuta get-upload y especifica la carga. ARN


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 tu especificación de prueba personalizadaupdate-upload, ejecuta y especifica la carga de la especificación ARN de prueba. Para obtener más información, consulte update-upload.

Paso 6: Programar una ejecución de prueba

Para programar una ejecución de prueba con AWS CLI, ejecuteschedule-run, especificando:

El proyecto ARN del paso 1.
El conjunto ARN de dispositivos del paso 2.
La carga ARN de la aplicación desde el paso 3.
La carga del paquete de prueba ARN desde el paso 4.

Si estás realizando pruebas en un entorno de pruebas personalizado, también necesitarás las especificaciones ARN de prueba del paso 5.

Para programar una ejecución en un entorno de pruebas estándar

Ejecute schedule-run y especifique la información del proyectoARN, el grupo de dispositivosARN, la carga ARN de aplicaciones y el paquete de prueba.

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 una ejecución ARN que puedes usar para comprobar el estado de la ejecución de la 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 schedule-run.

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

Usa el get-run comando y especifica la ejecuciónARN:


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 get-run. Para obtener información sobre el uso de Device Farm con AWS CLI, consulteReferencia de AWS CLI.

Creación de una ejecución de prueba (API)

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

Necesita esta información para llamar al ScheduleRunAPI:

Un proyectoARN. Consulte Crear un proyecto (API) y CreateProject.
Carga de una solicitudARN. Consulte CreateUpload.
Carga de un paquete de pruebaARN. Consulte CreateUpload.
Un grupo de dispositivosARN. Consulte Crear un grupo de dispositivos y CreateDevicePool.

nota

Si realizas pruebas en un entorno de pruebas personalizado, también necesitas subir ARN las especificaciones de las pruebas. Para obtener más información, consulte Paso 5: Cargar la especificación de prueba personalizada (opcional) y CreateUpload.

Para obtener información sobre el uso de Device FarmAPI, consulteAutomatización de Device Farm.

Siguientes pasos

En la consola de Device Farm, el icono de reloj se convertirá en un icono de resultado, como el icono de ejecución correcta The test succeeded. , 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 Farm.

Para usar el informe, siga las instrucciones que se indican en Trabajar con informes de pruebas en Device Farm.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Trabajar con ejecuciones de prueba

Establecimiento del tiempo de espera de ejecución