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.

# Integración de las pruebas de Appium con Device Farm
<a name="test-types-appium-integrate"></a>

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 Farm](test-types-appium.md).

## Configurar el paquete de prueba de Appium
<a name="test-types-appium-prepare"></a>

Utilice las siguientes instrucciones para configurar el paquete de pruebas.

------
#### [ Java (JUnit) ]

1. Modifique `pom.xml` para establecer el empaquetamiento como un archivo JAR:

   ```
   <groupId>com.acme</groupId>
   <artifactId>acme-myApp-appium</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   ```

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:

   ```
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-jar-plugin</artifactId>
     <version>2.6</version>
     <executions>
       <execution>
         <goals>
           <goal>test-jar</goal>
         </goals>
       </execution>
     </executions>
   </plugin>
   ```

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`: 

   ```
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-dependency-plugin</artifactId>
     <version>2.10</version>
     <executions>
       <execution>
         <id>copy-dependencies</id>
         <phase>package</phase>
         <goals>
           <goal>copy-dependencies</goal>
         </goals>
         <configuration>
           <outputDirectory>${project.build.directory}/dependency-jars/</outputDirectory>
         </configuration>
       </execution>
     </executions>
   </plugin>
   ```

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`: 

   ```
   <assembly
       xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
     <id>zip</id>
     <formats>
       <format>zip</format>
     </formats>
     <includeBaseDirectory>false</includeBaseDirectory>
     <fileSets>
       <fileSet>
         <directory>${project.build.directory}</directory>
         <outputDirectory>./</outputDirectory>
         <includes>
           <include>*.jar</include>
         </includes>
       </fileSet>
       <fileSet>
         <directory>${project.build.directory}</directory>
         <outputDirectory>./</outputDirectory>
         <includes>
           <include>/dependency-jars/</include>
         </includes>
       </fileSet>
     </fileSets>
   </assembly>
   ```

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**: 

   ```
   <plugin>
     <artifactId>maven-assembly-plugin</artifactId>
     <version>2.5.4</version>
     <executions>
       <execution>
         <phase>package</phase>
         <goals>
           <goal>single</goal>
         </goals>
         <configuration>
           <finalName>zip-with-dependencies</finalName>
           <appendAssemblyId>false</appendAssemblyId>
           <descriptors>
             <descriptor>src/main/assembly/zip.xml</descriptor>
           </descriptors>
         </configuration>
       </execution>
     </executions>
   </plugin>
   ```

**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`:  

```
<plugin>
  <artifactId>maven-compiler-plugin</artifactId>
  <configuration>
    <source>1.7</source>
    <target>1.7</target>
  </configuration>
</plugin>
```

------
#### [ Java (TestNG) ]

1. Modifique `pom.xml` para establecer el empaquetamiento como un archivo JAR:

   ```
   <groupId>com.acme</groupId>
   <artifactId>acme-myApp-appium</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   ```

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:

   ```
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-jar-plugin</artifactId>
     <version>2.6</version>
     <executions>
       <execution>
         <goals>
           <goal>test-jar</goal>
         </goals>
       </execution>
     </executions>
   </plugin>
   ```

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`: 

   ```
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-dependency-plugin</artifactId>
     <version>2.10</version>
     <executions>
       <execution>
         <id>copy-dependencies</id>
         <phase>package</phase>
         <goals>
           <goal>copy-dependencies</goal>
         </goals>
         <configuration>
           <outputDirectory>${project.build.directory}/dependency-jars/</outputDirectory>
         </configuration>
       </execution>
     </executions>
   </plugin>
   ```

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`: 

   ```
   <assembly
       xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
     <id>zip</id>
     <formats>
       <format>zip</format>
     </formats>
     <includeBaseDirectory>false</includeBaseDirectory>
     <fileSets>
       <fileSet>
         <directory>${project.build.directory}</directory>
         <outputDirectory>./</outputDirectory>
         <includes>
           <include>*.jar</include>
         </includes>
       </fileSet>
       <fileSet>
         <directory>${project.build.directory}</directory>
         <outputDirectory>./</outputDirectory>
         <includes>
           <include>/dependency-jars/</include>
         </includes>
       </fileSet>
     </fileSets>
   </assembly>
   ```

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**: 

   ```
   <plugin>
     <artifactId>maven-assembly-plugin</artifactId>
     <version>2.5.4</version>
     <executions>
       <execution>
         <phase>package</phase>
         <goals>
           <goal>single</goal>
         </goals>
         <configuration>
           <finalName>zip-with-dependencies</finalName>
           <appendAssemblyId>false</appendAssemblyId>
           <descriptors>
             <descriptor>src/main/assembly/zip.xml</descriptor>
           </descriptors>
         </configuration>
       </execution>
     </executions>
   </plugin>
   ```

**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`:  

```
<plugin>
  <artifactId>maven-compiler-plugin</artifactId>
  <configuration>
    <source>1.7</source>
    <target>1.7</target>
  </configuration>
</plugin>
```

------
#### [ Node.JS ]

Para empaquetar tus Node.js pruebas de Appium y subirlas a Device Farm, debes instalar lo siguiente en tu máquina 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
<a name="test-types-appium-create-a-zip"></a>

**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 \*.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 \*.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
<a name="test-types-appium-upload"></a>

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)
<a name="test-types-appium-screenshots"></a>

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.