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. # Marcos de pruebas y pruebas integradas en AWS Device Farm En esta sección se describe el soporte de Device Farm para marcos de prueba, así como los tipos de prueba integradas. Device Farm ejecuta pruebas automatizadas al hacer que subas tu aplicación y las pruebas a un bucket seguro de Amazon S3 gestionado por el servicio. Una vez cargada, activa la infraestructura subyacente, incluidos los [hosts de pruebas](custom-test-environments-hosts.md) gestionados por el servicio, y ejecuta las pruebas en paralelo en varios dispositivos. Los resultados de las pruebas se almacenan en un bucket de S3 gestionado por el servicio. Esta arquitectura se denomina **ejecución del lado del servicio** y es una forma rápida y eficiente de ejecutar pruebas en hosts que están físicamente cerca del dispositivo, sin necesidad de administrar usted mismo la infraestructura del host de prueba. Este enfoque se adapta bien para realizar pruebas en muchos dispositivos de forma independiente, así como para realizar pruebas desde el contexto de una CI/CD canalización. Para obtener más información sobre cómo ejecuta las pruebas Device Farm, consulte [Entornos de prueba de AWS Device Farm](test-environments.md). **nota** En el caso de los evaluadores de Appium, es posible que prefiera ejecutar las pruebas de Appium desde su entorno local. **Con una [sesión de acceso remoto](remote-access.md), puede ejecutar pruebas de Appium en el lado del cliente.** [Para obtener más información, consulta las pruebas de Appium en el lado del cliente.](appium-endpoint.md) ## Marcos de pruebas Device Farm admite estos marcos de automatización de pruebas móviles: ### Marcos de pruebas de aplicaciones Android + [Pruebas automáticas de AppiumIntegración de las pruebas de Appium](test-types-appium.md) + [Instrumentación](test-types-android-instrumentation.md) ### Marcos de pruebas de aplicaciones iOS + [Pruebas automáticas de AppiumIntegración de las pruebas de Appium](test-types-appium.md) + [XCTest](test-types-ios-xctest.md) + [XCTest INTERFAZ DE USUARIO](test-types-ios-xctest-ui.md) ### Marcos de pruebas de aplicaciones web Las aplicaciones web son compatibles con Appium. Para obtener más información sobre cómo llevar sus pruebas a Appium, consulte [Ejecute automáticamente pruebas de Appium en Device FarmIntegración de las pruebas de Appium con Device Farm](test-types-appium.md). ### Marcos en un entorno de prueba personalizado Device Farm no ofrece soporte para personalizar el entorno de prueba del XCTest marco. Para obtener más información, consulte [Personalización del entorno de pruebas personalizado en AWS Device Farm.](custom-test-environments.md). ### Compatibilidad con versiones de Appium Para las pruebas que se ejecutan en un entorno personalizado, Device Farm admite Appium versión 1. Para obtener más información, consulte [Entornos de prueba de AWS Device Farm](test-environments.md). ## Tipos de pruebas integradas Las pruebas integradas permiten probar la aplicación en varios dispositivos sin tener que escribir ni mantener scripts de automatización de pruebas. Device Farm ofrece un tipo de prueba integrada: + [Integrado: fuzzing (Android e iOS)](test-types-built-in-fuzz.md) # Ejecute automáticamente pruebas de Appium en Device Farm **nota** **En esta página, se describe la ejecución de las pruebas de Appium en el entorno de ejecución gestionado del lado del servidor de Device Farm.** [Para ejecutar pruebas de Appium desde su entorno local del lado del **cliente durante una sesión de acceso remoto, consulte las pruebas de Appium del lado del cliente**.](appium-endpoint.md) En esta sección, se describe cómo configurar, empaquetar y cargar las pruebas de Appium para ejecutarlas en el entorno gestionado del lado del servidor de Device Farm. Appium es una herramienta de código abierto que permite automatizar aplicaciones web nativas para dispositivos móviles. Para obtener más información, consulte [Introduction to Appium](http://appium.io/docs/en/latest/intro) en el sitio web de Appium. Para ver una aplicación de muestra y enlaces a pruebas de funcionamiento, consulte [Device Farm Sample App para Android](https://github.com/aws-samples/aws-device-farm-sample-app-for-android) y [Device Farm Sample App para iOS](https://github.com/aws-samples/aws-device-farm-sample-app-for-ios) en adelante GitHub. Para obtener más información sobre las pruebas en Device Farm y cómo funciona el lado del servidor, consulte. [Marcos de pruebas y pruebas integradas en AWS Device Farm](test-types.md) ## Selección de una versión de Appium **nota** Support para versiones específicas de Appium, controladores de Appium o programación SDKs dependerá del dispositivo y del host de prueba seleccionados para la ejecución de la prueba. Los hosts de prueba de Device Farm vienen preinstalados con Appium para permitir una configuración más rápida de las pruebas para casos de uso más sencillos. Sin embargo, el uso del archivo de especificaciones de prueba le permite instalar diferentes versiones de Appium si es necesario. ### Escenario 1: versión de Appium preconfigurada Device Farm viene preconfigurado con diferentes versiones de servidor Appium en función del host de prueba. El host viene con herramientas que habilitan la versión preconfigurada con el controlador predeterminado de la plataforma del dispositivo (UiAutomator2 para Android y 2 para XCUITest iOS). ``` phases: install: commands: - export APPIUM_VERSION=2 - devicefarm-cli use appium $APPIUM_VERSION ``` Para ver una lista del software compatible, consulte el tema en. [Software compatible en entornos de prueba personalizados](custom-test-environments-hosts-software.md) ### Escenario 2: versión personalizada de Appium Para seleccionar una versión personalizada de Appium, utilice el `npm` comando para instalarla. El siguiente ejemplo muestra cómo instalar la última versión de Appium 2. ``` phases: install: commands: - export APPIUM_VERSION=2 - npm install -g appium@$APPIUM_VERSION ``` ### Escenario 3: Appium en hosts iOS antiguos En el[Host de pruebas de iOS antiguo](custom-test-environments-hosts-ios.md#legacy-ios-host), puedes elegir versiones específicas de Appium con. `avm` Por ejemplo, para usar el `avm` comando para configurar la versión del servidor Appium`2.1.2`, agrega estos comandos a tu archivo YAML con especificaciones de prueba. ``` phases: install: commands: - export APPIUM_VERSION=2.1.2 - avm $APPIUM_VERSION ``` ## Selección de una WebDriverAgent versión para las pruebas de iOS Para ejecutar las pruebas de Appium en dispositivos iOS, WebDriverAgent es necesario el uso de. Esta aplicación debe estar firmada para poder instalarse en dispositivos iOS. Device Farm proporciona versiones prefirmadas WebDriverAgent que están disponibles durante la ejecución de entornos de prueba personalizados. El siguiente fragmento de código se puede utilizar para seleccionar una WebDriverAgent versión de Device Farm en el archivo de especificaciones de prueba que sea compatible con la versión de XCTest UI Driver. ``` phases: pre_test: commands: - |- APPIUM_DRIVER_VERSION=$(appium driver list --installed --json | jq -r ".xcuitest.version" | cut -d "." -f 1); CORRESPONDING_APPIUM_WDA=$(env | grep "DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V${APPIUM_DRIVER_VERSION}") if [[ ! -z "$APPIUM_DRIVER_VERSION" ]] && [[ ! -z "$CORRESPONDING_APPIUM_WDA" ]]; then echo "Using Device Farm's prebuilt WDA version ${APPIUM_DRIVER_VERSION}.x, which corresponds with your driver"; DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH=$(echo $CORRESPONDING_APPIUM_WDA | cut -d "=" -f2) else LATEST_SUPPORTED_WDA_VERSION=$(env | grep "DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V" | sort -V -r | head -n 1) echo "Unknown driver version $APPIUM_DRIVER_VERSION; falling back to the Device Farm default version of $LATEST_SUPPORTED_WDA_VERSION"; DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH=$(echo $LATEST_SUPPORTED_WDA_VERSION | cut -d "=" -f2) fi; ``` [Para obtener más información al respecto WebDriverAgent, consulte la documentación de Appium.](https://appium.github.io/appium-xcuitest-driver/9.10/guides/run-prebuilt-wda/) # Integración de las pruebas de Appium con Device Farm Siga estas instrucciones para integrar las pruebas de Appium con AWS Device Farm. Para obtener más información sobre las pruebas de Appium en Device Farm, consulte [Ejecute automáticamente pruebas de Appium en Device FarmIntegración de las pruebas de Appium con Device Farm](test-types-appium.md). ## Configurar el paquete de prueba de Appium Utilice las siguientes instrucciones para configurar el paquete de pruebas. ------ #### [ Java (JUnit) ] 1. Modifique `pom.xml` para establecer el empaquetamiento como un archivo JAR: ``` com.acme acme-myApp-appium 1.0-SNAPSHOT jar ``` 1. Modifique `pom.xml` para usar `maven-jar-plugin` para compilar las pruebas en un archivo JAR. El siguiente complemento compila el código fuente de la prueba (todo lo que haya en el directorio `src/test`) en un archivo JAR: ``` org.apache.maven.plugins maven-jar-plugin 2.6 test-jar ``` 1. Modifique `pom.xml` para usar `maven-dependency-plugin` para compilar dependencias como archivos JAR. El siguiente complemento copiará sus dependencias en el directorio `dependency-jars`: ``` org.apache.maven.plugins maven-dependency-plugin 2.10 copy-dependencies package copy-dependencies ${project.build.directory}/dependency-jars/ ``` 1. Guarde el siguiente ensamblaje XML en `src/main/assembly/zip.xml`. El siguiente XML es una definición de ensamblaje que, cuando está configurado, indica a Maven que compile un archivo .zip que contenga todo lo que haya en la raíz del directorio de salida de compilación y en el directorio `dependency-jars`: ``` zip zip false ${project.build.directory} ./ *.jar ${project.build.directory} ./ /dependency-jars/ ``` 1. Modifique `pom.xml` para usar `maven-assembly-plugin` para empaquetar las pruebas y todas las dependencias en un único archivo .zip. El siguiente complemento utiliza el ensamblaje anterior para crear un archivo .zip denominado `zip-with-dependencies` en el directorio de salida de compilación cada vez que se ejecuta **mvn package**: ``` maven-assembly-plugin 2.5.4 package single zip-with-dependencies false src/main/assembly/zip.xml ``` **nota** Si recibe un error que le informa de que la anotación no se admite en 1.3, añada lo siguiente a `pom.xml`: ``` maven-compiler-plugin 1.7 1.7 ``` ------ #### [ Java (TestNG) ] 1. Modifique `pom.xml` para establecer el empaquetamiento como un archivo JAR: ``` com.acme acme-myApp-appium 1.0-SNAPSHOT jar ``` 1. Modifique `pom.xml` para usar `maven-jar-plugin` para compilar las pruebas en un archivo JAR. El siguiente complemento compila el código fuente de la prueba (todo lo que haya en el directorio `src/test`) en un archivo JAR: ``` org.apache.maven.plugins maven-jar-plugin 2.6 test-jar ``` 1. Modifique `pom.xml` para usar `maven-dependency-plugin` para compilar dependencias como archivos JAR. El siguiente complemento copiará sus dependencias en el directorio `dependency-jars`: ``` org.apache.maven.plugins maven-dependency-plugin 2.10 copy-dependencies package copy-dependencies ${project.build.directory}/dependency-jars/ ``` 1. Guarde el siguiente ensamblaje XML en `src/main/assembly/zip.xml`. El siguiente XML es una definición de ensamblaje que, cuando está configurado, indica a Maven que compile un archivo .zip que contenga todo lo que haya en la raíz del directorio de salida de compilación y en el directorio `dependency-jars`: ``` zip zip false ${project.build.directory} ./ *.jar ${project.build.directory} ./ /dependency-jars/ ``` 1. Modifique `pom.xml` para usar `maven-assembly-plugin` para empaquetar las pruebas y todas las dependencias en un único archivo .zip. El siguiente complemento utiliza el ensamblaje anterior para crear un archivo .zip denominado `zip-with-dependencies` en el directorio de salida de compilación cada vez que se ejecuta **mvn package**: ``` maven-assembly-plugin 2.5.4 package single zip-with-dependencies false src/main/assembly/zip.xml ``` **nota** Si recibe un error que le informa de que la anotación no se admite en 1.3, añada lo siguiente a `pom.xml`: ``` maven-compiler-plugin 1.7 1.7 ``` ------ #### [ Node.JS ] Para empaquetar sus pruebas de Appium Node.js y cargarlas en Device Farm, debe instalar lo siguiente en su equipo local: + [Node Version Manager (nvm)](https://github.com/nvm-sh/nvm) Utilice esta herramienta cuando desarrolle y empaquete sus pruebas de forma que no se incluyan dependencias innecesarias en el paquete de pruebas. + Node.js + npm-bundle (instalado globalmente) 1. Verifique que nvm esté presente. ``` command -v nvm ``` Debería ver `nvm` como salida. Para obtener más información, consulte [nvm](https://github.com/nvm-sh/nvm) on. GitHub 1. Ejecute este comando para instalar Node.js: ``` nvm install node ``` Puede especificar una versión concreta de Node.js: ``` nvm install 11.4.0 ``` 1. Verifique que esté en uso la versión correcta de Node: ``` node -v ``` 1. Instale **npm-bundle** globalmente: ``` npm install -g npm-bundle ``` ------ #### [ Python ] 1. Le recomendamos que configure el módulo [virtualenv de Python](https://pypi.python.org/pypi/virtualenv) para desarrollar y empaquetar pruebas de forma que no se incluyan dependencias innecesarias en el paquete de la aplicación. ``` $ virtualenv workspace $ cd workspace $ source bin/activate ``` **sugerencia** No cree un módulo virtualenv de Python con la opción `--system-site-packages`, ya que hereda paquetes del directorio site-packages global. Esto puede dar lugar a que se incluyan en el entorno virtual dependencias que las pruebas no necesiten. También debería comprobar que las pruebas no utilizan dependencias que dependan de bibliotecas nativas, ya que esas bibliotecas nativas podrían no estar en la instancia en la que se ejecuten estas pruebas. 1. Instale **py.test** en el entorno virtual. ``` $ pip install pytest ``` 1. Instale el cliente de Appium Python en su entorno virtual. ``` $ pip install Appium-Python-Client ``` 1. A menos que especifique una ruta diferente en modo personalizado, Device Farm espera que sus pruebas se almacenen en `tests/`. Puede usar `find` para mostrar todos los archivos dentro de una carpeta: ``` $ find tests/ ``` Confirme que estos archivos contienen conjuntos de pruebas que quiere ejecutar en Device Farm ``` tests/ tests/my-first-tests.py tests/my-second-tests/py ``` 1. Ejecute este comando desde la carpeta de área de trabajo del entorno virtual para mostrar una lista de las pruebas sin ejecutarlas. ``` $ py.test --collect-only tests/ ``` Confirme que la salida muestra las pruebas que desea ejecutar en Device Farm. 1. Limpie todos los archivos almacenados en caché en sus pruebas/ carpeta: ``` $ find . -name '__pycache__' -type d -exec rm -r {} + $ find . -name '*.pyc' -exec rm -f {} + $ find . -name '*.pyo' -exec rm -f {} + $ find . -name '*~' -exec rm -f {} + ``` 1. Ejecute el comando siguiente en su espacio de trabajo para generar el archivo requirements.txt: ``` $ pip freeze > requirements.txt ``` ------ #### [ Ruby ] Para empaquetar sus pruebas de Appium Ruby y cargarlas en Device Farm, debe instalar lo siguiente en su equipo local: + [Ruby Version Manager (RVM)](https://rvm.io/rvm/install) Utilice esta herramienta de línea de comandos cuando desarrolle y empaquete sus pruebas de forma que no se incluyan dependencias innecesarias en el paquete de pruebas. + Ruby + Bundler (Esta gema normalmente se instala con Ruby). 1. Instale las claves requeridas, RVM y Ruby. Para obtener instrucciones, consulte [Instalación de RVM](https://rvm.io/rvm/install) en el sitio web de RVM. Una vez realizada la instalación, vuelva a cargar el terminal cerrando la sesión y volviéndola a iniciar a continuación. **nota** RVM se carga como función solo para el shell de bash. 1. Verifique que **rvm** está instalado correctamente. ``` command -v rvm ``` Debería ver `rvm` como salida. 1. Si quieres instalar una versión específica de Ruby, por ejemplo*2.5.3*, ejecuta el siguiente comando: ``` rvm install ruby 2.5.3 --autolibs=0 ``` Verifique que está en la versión solicitada de Ruby: ``` ruby -v ``` 1. Configure el paquete para compilar paquetes para las plataformas de prueba que desee: ``` bundle config specific_platform true ``` 1. Actualice su archivo .lock para añadir las plataformas necesarias para ejecutar las pruebas. + Si está compilando pruebas para ejecutarlas en dispositivos Android, ejecute este comando para configurar el Gemfile de manera que use dependencias para el host de pruebas de Android: ``` bundle lock --add-platform x86_64-linux ``` + Si está compilando pruebas para ejecutarlas en dispositivos iOS, ejecute este comando para configurar el Gemfile de manera que use dependencias para el host de pruebas de iOS: ``` bundle lock --add-platform x86_64-darwin ``` 1. Por lo general, la gema **bundler** está instalada de forma predeterminada. Si no es así, instálela: ``` gem install bundler -v 2.3.26 ``` ------ ## Crear un archivo de paquete comprimido **aviso** En Device Farm, la estructura de carpetas de los archivos del paquete de prueba comprimido es importante, y algunas herramientas de archivado cambiarán la estructura del archivo ZIP de forma implícita. Le recomendamos que utilice las utilidades de línea de comandos que se especifican a continuación en lugar de utilizar las utilidades de archivado integradas en el administrador de archivos del escritorio local (como Finder o el Explorador de Windows). Ahora, agrupe las pruebas para Device Farm. ------ #### [ Java (JUnit) ] Cree y empaquete las pruebas: ``` $ mvn clean package -DskipTests=true ``` El archivo `zip-with-dependencies.zip` se creará como resultado. Este es el paquete de prueba. ------ #### [ Java (TestNG) ] Cree y empaquete las pruebas: ``` $ mvn clean package -DskipTests=true ``` El archivo `zip-with-dependencies.zip` se creará como resultado. Este es el paquete de prueba. ------ #### [ Node.JS ] 1. Revise su proyecto. Asegúrese de que se encuentra en el directorio raíz del proyecto. Puede ver `package.json` en el directorio raíz. 1. Ejecute este comando para instalar sus dependencias locales. ``` npm install ``` Este comando también crea una carpeta `node_modules` en el directorio actual. **nota** En este momento, debería poder ejecutar las pruebas localmente. 1. Ejecute este comando para empaquetar los archivos en su carpeta actual en un archivo \$1.tgz. El archivo se nombra utilizando la propiedad `name` en su archivo `package.json`. ``` npm-bundle ``` Este archivo tar (.tgz) contiene todo el código y todas las dependencias. 1. Ejecute este comando para agrupar el archivo tar (archivo \$1.tgz) generado en el paso anterior en un archivo comprimido: ``` zip -r MyTests.zip *.tgz ``` Este es el archivo `MyTests.zip` que carga en Device Farm en el procedimiento siguiente. ------ #### [ Python ] Python 2 Genere un archivo de los paquetes requeridos con Python (llamado «wheelhouse») usando pip: ``` $ pip wheel --wheel-dir wheelhouse -r requirements.txt ``` Empaquete su wheelhouse, pruebas y requisitos de pip en un archivo zip para Device Farm: ``` $ zip -r test_bundle.zip tests/ wheelhouse/ requirements.txt ``` Python 3 Empaquete sus pruebas y requisitos de pip en un archivo zip: ``` $ zip -r test_bundle.zip tests/ requirements.txt ``` ------ #### [ Ruby ] 1. Ejecute este comando para crear un entorno virtual de Ruby: ``` # myGemset is the name of your virtual Ruby environment rvm gemset create myGemset ``` 1. Ejecute este comando para utilizar el entorno que acaba de crear: ``` rvm gemset use myGemset ``` 1. Revise el código fuente. Asegúrese de que se encuentra en el directorio raíz del proyecto. Puede ver `Gemfile` en el directorio raíz. 1. Ejecute este comando para instalar sus dependencias locales y todas las gemas del `Gemfile`: ``` bundle install ``` **nota** En este momento, debería poder ejecutar las pruebas localmente. Utilice este comando para ejecutar una prueba localmente: ``` bundle exec $test_command ``` 1. Empaquete las gemas en la carpeta `vendor/cache`. ``` # This will copy all the .gem files needed to run your tests into the vendor/cache directory bundle package --all-platforms ``` 1. Ejecute el comando siguiente para empaquetar el código fuente, junto con todas sus dependencias, en un solo archivo comprimido: ``` zip -r MyTests.zip Gemfile vendor/ $(any other source code directory files) ``` Este es el archivo `MyTests.zip` que carga en Device Farm en el procedimiento siguiente. ------ ## Cargar el paquete de prueba en Device Farm Puede utilizar la consola de Device Farm para cargar las pruebas. 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 de Device Farm, seleccione **Pruebas de dispositivos móviles** y, a continuación, seleccione **Proyectos**. 1. Si es un usuario nuevo, seleccione **Nuevo proyecto**, introduzca un nombre para el proyecto y, a continuación, seleccione **Enviar**. Si ya dispone de un proyecto, puede seleccionarlo para cargar las pruebas en él. 1. Abra el proyecto y, a continuación, seleccione **Crear ejecución**. 1. En **Configuración de ejecución**, asigne un nombre adecuado a la prueba. Puede contener cualquier combinación de espacios o signos de puntuación. 1. Para pruebas nativas de iOS y Android En **Configuración de ejecución**, seleccione **Aplicación Android** si está probando una aplicación Android (.apk) o elija **Aplicación iOS** si está probando una aplicación iOS (.ipa). A continuación, en **Seleccionar aplicación**, elija **Cargar aplicación propia** para cargar el paquete distribuible de la aplicación. El archivo debe ser un `.apk` de Android o un `.ipa` de iOS. Las aplicaciones de iOS se deben compilar para dispositivos reales, no para el simulador. Para pruebas de aplicaciones web móviles En **Configuración de ejecución**, elija **Aplicación web**. 1. En **Configurar prueba**, en la sección **Seleccionar marco de prueba**, elija el marco de Appium con el que va a realizar las pruebas y, a continuación, **Cargue su propio paquete de prueba**. 1. Busque y elija el archivo .zip que contiene las pruebas. El archivo .zip debe respetar el formato que se describe en [Configurar el paquete de prueba de Appium](#test-types-appium-prepare). 1. Siga las instrucciones para seleccionar dispositivos e inicie la ejecución. Para obtener más información, consulte [Creación de una ejecución de prueba en Device Farm](how-to-create-test-run.md). **nota** Device Farm no modifica las pruebas de Appium. ## Realizar capturas de pantalla de sus pruebas (opcional) Puede realizar capturas de pantalla como parte de las pruebas. Device Farm establece la propiedad `DEVICEFARM_SCREENSHOT_PATH` en una ruta completa del sistema de archivos local donde Device Farm espera que se almacenen las capturas de pantalla de Appium. El directorio específico de la prueba donde se almacenan las capturas de pantalla se define en tiempo de ejecución. Las capturas de pantalla se extraen en los informes de Device Farm automáticamente. Para ver las capturas de pantalla en la consola de Device Farm, seleccione la sección **Capturas de pantalla**. Para obtener más información sobre cómo realizar capturas de pantalla en pruebas de Appium, consulte [Realizar una captura de pantalla](http://appium.io/docs/en/commands/session/screenshot/) en la documentación de la API de Appium. # Pruebas de Android en AWS Device Farm Device Farm es compatible con varios tipos de pruebas de automatización para dispositivos Android y dos pruebas integradas. Para obtener más información sobre las pruebas en Device Farm, consulte [Marcos de pruebas y pruebas integradas en AWS Device Farm](test-types.md). ## Marcos de pruebas de aplicaciones Android Las siguientes pruebas están disponibles para dispositivos Android. + [Pruebas automáticas de AppiumIntegración de las pruebas de Appium](test-types-appium.md) + [Instrumentación](test-types-android-instrumentation.md) ## Tipos de pruebas integradas para Android Existe un tipo de prueba integrada disponible para dispositivos Android: + [Integrado: fuzzing (Android e iOS)](test-types-built-in-fuzz.md) # Instrumentación para Android y AWS Device Farm Device Farm ofrece soporte para instrumentación (EspressoJUnit, Robotium o cualquier prueba basada en instrumentación) para Android. Device Farm también ofrece una aplicación Android de ejemplo y enlaces a pruebas activas en tres marcos de automatización de Android, incluida la instrumentación (Espresso). La [aplicación de muestra Device Farm para Android](https://github.com/awslabs/aws-device-farm-sample-app-for-android) está disponible para su descarga en GitHub. Para obtener más información sobre las pruebas en Device Farm, consulte [Marcos de pruebas y pruebas integradas en AWS Device Farm](test-types.md). **Topics** + [ ## ¿Qué es la instrumentación? ](#test-types-android-instrumentation-what-is) + [ ## Consideraciones sobre las pruebas de instrumentación de Android ](#test-types-android-instrumentation-settings) + [ ## Análisis de prueba en modo estándar ](#test-types-android-standard-mode-test-parse) + [ # Integración de la instrumentación de Android con Device Farm ](test-types-android-instrumentation-integrate.md) ## ¿Qué es la instrumentación? La instrumentación para Android le permite invocar métodos de devolución de llamada en el código de la prueba, de manera que pueda seguir paso a paso todo el ciclo de vida de un componente como si lo estuviera depurando. Para obtener más información, consulte [Instrumented tests (Pruebas instrumentalizadas)](https://developer.android.com/studio/test/test-in-android-studio#test_types_and_locations) en la sección *Aspectos básicos de las pruebas* de la documentación *Herramientas para el desarrollador de Android*. ## Consideraciones sobre las pruebas de instrumentación de Android Al utilizar la instrumentación de Android, tenga en cuenta las siguientes recomendaciones y notas. **Comprobación de la compatibilidad con el sistema operativo Android** Consulte la [documentación de Android](https://developer.android.com/jetpack/androidx/releases/test#orchestrator-1.5.0) para asegurarse de que la instrumentación sea compatible con su versión del sistema operativo Android. **Instalación desde la línea de comandos** Para ejecutar las pruebas de instrumentación desde la línea de comandos, consulte la [Documentación de Android](https://developer.android.com/training/testing/instrumented-tests/androidx-test-libraries/runner#enable-command). **Animaciones del sistema** Según la [documentación de Android para pruebas de Espresso](https://developer.android.com/training/testing/espresso), se recomienda que las animaciones del sistema estén desactivadas al realizar pruebas en dispositivos reales. Device Farm deshabilita automáticamente los ajustes **Window Animation Scale**, **Transition Animation Scale y Animator** **Duration Scale** cuando se ejecuta con el ejecutor de pruebas de instrumentación [android.support.test.Runner.Android Runner. JUnit](http://developer.android.com/reference/android/support/test/runner/AndroidJUnitRunner.html) **Grabadores de pruebas** Device Farm admite marcos, como Robotium, que tienen herramientas de record-and-playback creación de scripts. ## Análisis de prueba en modo estándar En el modo estándar de ejecución, Device Farm analiza el conjunto de pruebas e identifica las clases y métodos de prueba únicos que se ejecutarán. Esto se hace a través de una herramienta llamada [Dex Test Parser](https://github.com/linkedin/dex-test-parser). Cuando se introduce un archivo.apk de instrumentación de Android como entrada, el analizador devuelve los nombres de métodos completos de las pruebas que coinciden con JUnit las convenciones 3 y 4. JUnit Para probar esto en un entorno local: 1. Descargue el documento binario [https://github.com/linkedin/dex-test-parser](https://github.com/linkedin/dex-test-parser). 1. Ejecute el siguiente comando para obtener la lista de métodos de prueba que se ejecutarán en Device Farm: ``` java -jar parser.jar path/to/apk path/for/output ``` # Integración de la instrumentación de Android con Device Farm **nota** Siga estas instrucciones para integrar las pruebas de instrumentación de Android con AWS Device Farm. Para obtener más información sobre las pruebas de instrumentación en Device Farm, consulte [Instrumentación para Android y AWS Device Farm](test-types-android-instrumentation.md). ## Carga de las pruebas de instrumentación para Android Utilice la consola de Device Farm para cargar las pruebas. 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 de Device Farm, seleccione **Pruebas de dispositivos móviles** y, a continuación, seleccione **Proyectos**. 1. En la lista de proyectos, seleccione el proyecto en el que desea cargar las pruebas. **sugerencia** Puede utilizar la barra de búsqueda para filtrar la lista de proyectos por nombre. Para crear un proyecto, siga las instrucciones de [Creación de un proyecto en AWS Device Farm](how-to-create-project.md). 1. Seleccione **Crear regla**. 1. En **Seleccionar aplicación**, en la sección **Opciones de selección de aplicaciones**, elija **Cargar aplicación propia**. 1. Busque y elija el archivo de aplicación de Android. El archivo debe ser un archivo .apk. 1. En la página **Configurar prueba**, en la sección **Seleccionar marco de pruebas**, elija **Instrumentación** y, a continuación, **Elegir archivo**. 1. Busque y elija el archivo .apk que contiene las pruebas. 1. Complete el resto de instrucciones para seleccionar dispositivos e inicie la ejecución. ## (Opcional) Capturas de pantalla en pruebas de instrumentación de Android Puede realizar capturas de pantalla como parte de las pruebas de instrumentación para Android. Para realizar capturas de pantalla, llame a uno de los siguientes métodos: + Para Robotium, llame al método `takeScreenShot` (por ejemplo, `solo.takeScreenShot();`). + Para Spoon, llame al método `screenshot`, por ejemplo: ``` Spoon.screenshot(activity, "initial_state"); /* Normal test code... */ Spoon.screenshot(activity, "after_login"); ``` Durante una ejecución de prueba, Device Farm obtiene automáticamente capturas de pantalla de las siguientes ubicaciones de los dispositivos, si las hay. A continuación, las añade a los informes de las pruebas: + `/sdcard/robotium-screenshots` + `/sdcard/test-screenshots` + `/sdcard/Download/spoon-screenshots/test-class-name/test-method-name` + `/data/data/application-package-name/app_spoon-screenshots/test-class-name/test-method-name` # Pruebas de iOS en AWS Device Farm Device Farm es compatible con varios tipos de pruebas de automatización para dispositivos iOS y una prueba integrada. Para obtener más información sobre las pruebas en Device Farm, consulte [Marcos de pruebas y pruebas integradas en AWS Device Farm](test-types.md). ## Marcos de pruebas de aplicaciones iOS Las siguientes pruebas están disponibles para dispositivos iOS. + [Pruebas automáticas de AppiumIntegración de las pruebas de Appium](test-types-appium.md) + [XCTest](test-types-ios-xctest.md) + [XCTest INTERFAZ DE USUARIO](test-types-ios-xctest-ui.md) ## Tipos de pruebas integradas para iOS Actualmente hay un tipo de prueba integrada disponible para dispositivos iOS. + [Integrado: fuzzing (Android e iOS)](test-types-built-in-fuzz.md) # Integración de Device Farm con XCTest iOS Con Device Farm, puedes usar el XCTest marco para probar tu aplicación en dispositivos reales. Para obtener más información XCTest, consulta [los aspectos básicos](https://developer.apple.com/library/ios/documentation/DeveloperTools/Conceptual/testing_with_xcode/chapters/03-testing_basics.html) de las *pruebas con Xcode*. Para ejecutar una prueba, debe crear los paquetes de la ejecución de prueba y cargar estos paquetes en Device Farm. Para obtener más información sobre las pruebas en Device Farm, consulte [Marcos de pruebas y pruebas integradas en AWS Device Farm](test-types.md). **Topics** + [ ## Crea los paquetes para tu ejecución XCTest ](#test-types-ios-xctest-create-packages) + [ ## Sube los paquetes para tu XCTest carrera a Device Farm ](#test-types-ios-xctest-upload) ## Crea los paquetes para tu ejecución XCTest Para probar la aplicación mediante el XCTest marco, Device Farm requiere lo siguiente: + El paquete de la aplicación como un archivo `.ipa`. + Tu XCTest paquete como un `.zip` archivo. Para crear estos paquetes, utilice la salida de la compilación que Xcode genera. Siga los pasos que se describen a continuación para crear los paquetes de modo que pueda cargarlos en Device Farm. **Para generar la salida de la compilación para su aplicación** 1. Abra el proyecto de la aplicación en Xcode. 1. En el menú desplegable de esquema en la barra de herramientas de Xcode, seleccione **Dispositivo iOS genérico** como destino. 1. En el menú **Producto**, seleccione **Compilar para** y, a continuación, seleccione **Pruebas**. **Para crear el paquete de la aplicación** 1. En el navegador del proyecto Xcode, en **Productos**, abra el menú contextual del archivo denominado `app-project-name.app`. A continuación, seleccione **Mostrar en Finder**. Finder abre una carpeta con el nombre `Debug-iphoneos`, que contiene la salida que Xcode generó para su compilación de prueba. Esta carpeta incluye su archivo `.app`. 1. En Finder, cree una nueva carpeta y asígnele el nombre `Payload`. 1. Copie el archivo `app-project-name.app` y péguelo en la carpeta `Payload`. 1. Abra el menú contextual de la carpeta `Payload` y seleccione **Comprimir "Payload"**. Se crea un archivo denominado `Payload.zip`. 1. Cambie el nombre y la extensión del archivo `Payload.zip` a `app-project-name.ipa`. En un paso posterior, proporcionará este nombre de archivo a Device Farm. Para que sea más fácil encontrar el archivo, es recomendable que lo mueva a otra ubicación, como el escritorio. 1. Si lo prefiere, puede eliminar la carpeta `Payload` y el archivo `.app` que contiene. **Para crear el XCTest paquete** 1. En Finder, en el directorio `Debug-iphoneos`, abra el menú contextual del archivo `app-project-name.app`. A continuación, seleccione **Mostrar contenidos del paquete**. 1. En el contenido del paquete, abra la carpeta `Plugins`. Esta carpeta contiene un archivo denominado `app-project-name.xctest`. 1. Abra el menú contextual de este archivo y seleccione **Comprimir "`app-project-name.xctest`"**. Se crea un archivo denominado `app-project-name.xctest.zip`. En un paso posterior, proporcionará este nombre de archivo a Device Farm. Para que sea más fácil encontrar el archivo, es recomendable que lo mueva a otra ubicación, como el escritorio. ## Sube los paquetes para tu XCTest carrera a Device Farm Utilice la consola de Device Farm para cargar los paquetes de la prueba. 1. Inicie sesión en la consola de Device Farm en [https://console.aws.amazon.com/devicefarm.](https://console.aws.amazon.com/devicefarm) 1. Si todavía no tiene un proyecto, cree uno. Para conocer los pasos necesarios para crear un proyecto, consulte [Creación de un proyecto en AWS Device Farm](how-to-create-project.md). De lo contrario, en el panel de navegación de Device Farm, seleccione **Pruebas de dispositivos móviles** y, a continuación, seleccione **Proyectos**. 1. Seleccione el proyecto que desea utilizar para ejecutar la prueba. 1. Seleccione **Crear ejecución**. 1. En **Configuración de ejecución**, en la sección **Tipo de ejecución**, seleccione **Aplicación iOS**. 1. En **Seleccionar aplicación**, en la sección **Opciones de selección de aplicaciones**, elija **Cargar aplicación propia**. A continuación, seleccione **Elegir archivo** en **Cargar aplicación**. 1. Desplácese hasta el archivo `.ipa` de la aplicación y cárguelo. **nota** El paquete `.ipa` debe estar compilado para pruebas. 1. En **Configurar prueba**, en la sección **Seleccionar marco de prueba**, elija. **XCTest** A continuación, seleccione **Elegir archivo** en **Cargar aplicación**. 1. Busca el `.zip` archivo que contiene el XCTest paquete de tu aplicación y cárgalo. 1. Complete los demás pasos del proceso de creación del proyecto. Seleccionará los dispositivos en los que desea hacer las pruebas y especificará el estado del dispositivo. 1. Seleccione **Crear ejecución**. Device Farm ejecuta su prueba y muestra los resultados en la consola. # Integración de la XCTest interfaz de usuario para iOS con Device Farm Device Farm proporciona soporte para el marco de pruebas de la XCTest interfaz de usuario. [En concreto, Device Farm admite pruebas de XCTest interfaz de usuario escritas tanto en Objective-C como en Swift.](https://developer.apple.com/swift/) El marco de la XCTest interfaz de usuario permite realizar pruebas de interfaz de usuario en el desarrollo de iOS, basadas en XCTest. Para obtener más información, consulte [User Interface Testing](https://developer.apple.com/library/prerelease/ios/documentation/DeveloperTools/Conceptual/testing_with_xcode/chapters/09-ui_testing.html#//apple_ref/doc/uid/TP40014132-CH13-SW1) en la iOS Developer Library. Para obtener información general sobre las pruebas en Device Farm, consulte [Marcos de pruebas y pruebas integradas en AWS Device Farm](test-types.md). Sigue las instrucciones siguientes para integrar Device Farm con el marco de pruebas de XCTest interfaz de usuario para iOS. **Topics** + [ ## Prepara tus pruebas de XCTest interfaz de usuario de iOS ](#test-types-ios-xctest-ui-prepare) + [ ## Opción 1: Crear un paquete XCTest UI .ipa ](#how-to-use-create-XCTestUI-ipa-package) + [ ## Opción 2: Crear un paquete .zip de XCTest interfaz de usuario ](#how-to-use-create-XCTestUI-zip-package) + [ ## Sube tus pruebas de XCTest interfaz de usuario de iOS ](#test-types-ios-xctest-ui-upload) ## Prepara tus pruebas de XCTest interfaz de usuario de iOS Puede cargar un archivo `.ipa` o `.zip` para su paquete de pruebas de XCTEST\$1UI. Un archivo `.ipa` es un archivo de aplicaciones que contiene la aplicación iOS Runner en formato de paquete. *No se pueden incluir archivos adicionales dentro del archivo `.ipa`.* Si sube un archivo `.zip`, puede contener directamente la aplicación iOS Runner o un archivo `.ipa`. También puede incluir otros archivos dentro del archivo `.zip` si desea utilizarlos durante las pruebas. Por ejemplo, puede incluir archivos como `.xctestrun`, `.xcworkspace` o `.xcodeproj` dentro de un archivo `.zip`, para ejecutar los planes de pruebas de XCUI en una granja de dispositivos. Las instrucciones detalladas sobre cómo ejecutar los planes de pruebas están disponibles en el archivo de especificaciones de pruebas predeterminado para el tipo de prueba XCUI. ## Opción 1: Crear un paquete XCTest UI .ipa El paquete *yourAppName*UITest-Runner.app lo crea Xcode cuando compilas tu proyecto para probarlo. Se encuentra en el directorio Products del proyecto. Para crear un archivo .ipa: 1. Cree un directorio denominado *Payload*. 1. Añada el directorio de aplicaciones al directorio Payload. 1. Archive el directorio Payload en un archivo `.zip` y, a continuación, cambie la extensión del archivo a `.ipa`. La siguiente estructura de carpetas muestra cómo se *my-project-nameUITest-Runner.app* empaquetaría como un archivo una aplicación de ejemplo llamada: `.ipa` ``` . └── my-project-nameUITest.ipa └── Payload (directory) └── my-project-nameUITest-Runner.app ``` ## Opción 2: Crear un paquete .zip de XCTest interfaz de usuario Device Farm genera automáticamente un `.xctestrun` archivo para ejecutar todo el conjunto de pruebas de XCTest interfaz de usuario. Si quiere usar su propio archivo `.xctestrun` en Device Farm, puede comprimir sus archivos `.xctestrun` y el directorio de aplicaciones en un archivo `.zip`. Si ya tiene un `.ipa` archivo para su paquete de prueba, puede incluirlo aquí en su lugar*\$1-Runner.app*. ``` . └── swift-sample-UI.zip (directory) ├── my-project-nameUITest-Runner.app [OR] my-project-nameUITest.ipa ├── SampleTestPlan_2.xctestrun ├── SampleTestPlan_1.xctestrun └── (any other files) ``` Si quieres ejecutar un plan de pruebas de Xcode para tus pruebas de XCUI en Device Farm, puedes crear un zip que contenga el *my-project-nameUITestarchivo.app **o my-project-name** *UITest.ipa* de Runner.app* y los archivos de código fuente de xcode necesarios para ejecutar XCTEST\$1UI con planes de pruebas, incluido un archivo o. `.xcworkspace` `.xcodeproj` A continuación, se muestra un ejemplo de zip con un archivo `.xcodeproj`: ``` . └── swift-sample-UI.zip (directory) ├── my-project-nameUITest-Runner.app [OR] my-project-nameUITest.ipa ├── (any directory) └── SampleXcodeProject.xcodeproj ├── Testplan_1.xctestplan ├── Testplan_2.xctestplan └── (any other source code files created by xcode with .xcodeproj) ``` A continuación, se muestra un ejemplo de zip con un archivo `.xcworkspace`: ``` . └──swift-sample-UI.zip (directory) ├── my-project-nameUITest-Runner.app [OR] my-project-nameUITest.ipa └── (any directory) │ ├── SampleXcodeProject.xcodeproj │ ├── Testplan_1.xctestplan │ ├── Testplan_2.xctestplan | └── (any other source code files created by xcode with .xcodeproj) └── SampleWorkspace.xcworkspace └── contents.xcworkspacedata ``` **nota** Asegúrese de no tener un directorio llamado «Payload» dentro del paquete .zip de la interfaz de usuario. XCTest ## Sube tus pruebas de XCTest interfaz de usuario de iOS Utilice la consola de Device Farm para cargar las pruebas. 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 de Device Farm, seleccione **Pruebas de dispositivos móviles** y, a continuación, seleccione **Proyectos**. 1. En la lista de proyectos, seleccione el proyecto en el que desea cargar las pruebas. **sugerencia** Puede utilizar la barra de búsqueda para filtrar la lista de proyectos por nombre. Para crear un proyecto, siga las instrucciones de [Creación de un proyecto en AWS Device Farm](how-to-create-project.md). 1. Seleccione **Crear ejecución**. 1. En **Configuración de ejecución**, en la sección **Tipo de ejecución**, seleccione **Aplicación iOS**. 1. En **Seleccionar aplicación**, en la sección **Opciones de selección de aplicaciones**, elija **Cargar aplicación propia**. A continuación, seleccione **Elegir archivo** en **Cargar aplicación**. 1. Busque y elija el archivo de aplicación de iOS. El archivo debe ser un archivo .ipa. **nota** Asegúrese de que el archivo .ipa se ha compilado para un dispositivo iOS y no para un simulador. 1. **En **Configurar la prueba**, en la sección **Seleccionar el marco de prueba**, elija UI. XCTest ** A continuación, seleccione **Elegir archivo** en **Cargar aplicación**. 1. Busca y selecciona el archivo.ipa o .zip que contiene tu ejecutor de pruebas de XCTest interfaz de usuario de iOS. 1. Complete los demás pasos del proceso de creación de la ejecución. Seleccione los dispositivos en los que desea realizar la prueba y, de manera opcional, puede especificar una configuración adicional. 1. Seleccione **Crear ejecución**. Device Farm ejecuta su prueba y muestra los resultados en la consola. # Pruebas de aplicaciones web en AWS Device Farm Device Farm ofrece pruebas con Appium para aplicaciones web. Para obtener más información sobre cómo configurar las pruebas de Appium en Device Farm, consulte. [Ejecute automáticamente pruebas de Appium en Device Farm](test-types-appium.md) Para obtener más información sobre las pruebas en Device Farm, consulte [Marcos de pruebas y pruebas integradas en AWS Device Farm](test-types.md). ## Reglas para dispositivos con y sin medidor La medición hace referencia a la facturación para dispositivos. De forma predeterminada, se realiza una medición de los dispositivos de Device Farm y se le cobrará por minuto después de que consuma los minutos de evaluación gratuitos. También puede optar por adquirir dispositivos sin medidor, lo que le permite realizar un número ilimitado de pruebas por una tarifa plana mensual. Para obtener más información, consulte los [precios de AWS Device Farm](https://aws.amazon.com/device-farm/). Si decide comenzar una ejecución con un grupo de dispositivos que contenga tanto dispositivos iOS como Android, existen reglas para los dispositivos con y sin medidor. Por ejemplo, si tiene cinco dispositivos Android sin medidor y cinco dispositivos iOS sin medidor, las ejecuciones de pruebas web utilizarán los dispositivos sin medidor. Este es otro ejemplo: supongamos que tiene cinco dispositivos Android sin medidor y 0 dispositivos iOS sin medidor. Si selecciona solo dispositivos Android para la ejecución web, se usarán los dispositivos sin medidor. Si selecciona tanto dispositivos Android como iOS para la ejecución web, el método de facturación se medirá y no se usarán los dispositivos sin medidor. # Pruebas integradas en AWS Device Farm Device Farm es compatible con diversos tipos de pruebas integradas para dispositivos Android e iOS. Las pruebas integradas permiten probar la aplicación en varios dispositivos sin tener que escribir ni mantener scripts de automatización de pruebas. Esto puede ahorrarle tiempo y esfuerzo, especialmente cuando esté empezando a usar Device Farm. Device Farm ofrece el siguiente tipo de prueba integrada: + [Integrado: fuzzing (Android e iOS)](test-types-built-in-fuzz.md): la prueba de difusión integrada envía de forma aleatoria eventos de interfaz de usuario a los dispositivos y, a continuación, crea un informe con los resultados. Para obtener más información sobre las pruebas y los marcos de pruebas en Device Farm, consulte [Marcos de pruebas y pruebas integradas en AWS Device Farm](test-types.md). # Ejecución de la prueba de difusión integrada de Device Farm (Android e iOS) La prueba de difusión integrada de Device Farm envía de forma aleatoria eventos de interfaz de usuario a los dispositivos y, a continuación, crea un informe con los resultados. Para obtener más información sobre las pruebas en Device Farm, consulte [Marcos de pruebas y pruebas integradas en AWS Device Farm](test-types.md). **Cómo ejecutar la prueba de difusión integrada** 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 de Device Farm, seleccione **Pruebas de dispositivos móviles** y, a continuación, seleccione **Proyectos**. 1. En la lista de proyectos, seleccione el proyecto en el que desea ejecutar la prueba de difusión integrada. **sugerencia** Puede utilizar la barra de búsqueda para filtrar la lista de proyectos por nombre. Para crear un proyecto, siga las instrucciones de [Creación de un proyecto en AWS Device Farm](how-to-create-project.md). 1. Seleccione **Crear ejecució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). 1. En **Seleccionar aplicación**, 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. 1. En la página **Configurar prueba**, en la sección **Seleccionar marco de pruebas**, elija **Integrado: fuzzing**. 1. Si aparece cualquiera de los siguientes ajustes, puede aceptar los valores predeterminados o especificar los suyos propios: + **Recuento de eventos**: especifique un número entre 1 y 10 000, que representa el número de eventos de interfaz de usuario que va a realizar la prueba de difusión. + **Acelerador de eventos**: especifique un número entre 0 y 1000, que representa el número de milisegundos que debe esperar la prueba de difusión antes de realizar el siguiente evento de interfaz de usuario. + **Semilla aleatorizadora**: especifique un número que usará la prueba de difusión para aleatorizar los eventos de interfaz de usuario. Si se especifica el mismo número en las subsiguientes pruebas de difusión, las secuencias de eventos serán idénticas. 1. Complete el resto de instrucciones para seleccionar dispositivos e inicie la ejecución.