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