Testing web en dispositivos móviles mediante Appium

Introducción

Hoy en día muchos “sites” reciben más visitas por parte de dispositivos móviles. Esto ha hecho que las empresas quieran invertir cada vez más esfuerzos en “testear” sus aplicaciones web en sistemas operativos móviles (android, ios, windows etc.).

Podemos testear nuestras aplicaciones móviles en dispositivos reales o virtuales, cada una de las opciones con sus ventajas y desventajas:

Testing en dispositivos reales

  • Su mayor ventaja es que las pruebas van a ser reales y objetivas ya que estamos probando contra el dispositivo real.
  • Su mayor desventaja es que es necesario de grandes recursos económicos, dado que necesitamos tener más de un dispositivo con diferentes versiones de SO para garantizar una buena cobertura. Normalmente se hace un estudio previo de los dispositivos y SO más utilizados o los que más acceden a nuestra aplicación. Por no decir que gestionar una “granja” de dispositivos móviles no es fácil y es caro.

Testing en dispositivos virtuales

  • Su mayor ventaja se basa en la capacidad de crear diferentes imágenes de dispositivos y SO de una forma rápida y barata.
  • Su desventaja es que las pruebas no son del todo reales y objetivas debido a que no lo lanzamos contra un dispositivo real.

Aún así en mi caso prefiero realizar pruebas sobre dispositivos reales, y es lo que haremos en este post.

Amazon AWS

Pero antes de meternos a diseñar la arquitectura de nuestra “mini granja” y desarollar las pruebas, es necesario comentar que si vuestra empresa tiene recursos económicos suficientes, Amazon dispone de una granja de dispositivos móviles en los que podréis hacer pruebas.

https://aws.amazon.com/blogs/aws/aws-device-farm-test-mobile-apps-on-real-devices/

Arquitectura del entorno de pruebas

Antes de empezar a desarrollar el proyecto de pruebas tenemos que pensar en como queremos que sea nuestro entorno de pruebas. Para eso debemos tener en cuenta nuestras necesidades.

La arquitectura de ejemplo que planteo se basa en los siguientes componentes:

Appium arquitectura

  • Servidor Appium para SO Android: Servidor en el que se encontraran conectados los dispositivos android en los que se lanzaran las pruebas. Más información sobre Appium.
  • Servidor Appium para SO iOS: Servidor en el que se encontrarán conectados los dispositivos iOS en los que se lanzaran las pruebas. Para lanzar las pruebas en SO iOS son necesarias las librerias OS X por lo que necesitaremos un entorno MacOS.
  • Repositorio Git: Repositorio donde se encuentran los proyectos de testing. En mi caso uso GitHub.
  • Jenkins: Jenkins se encargará de lanzar las tareas de testing. Descargará los proyectos del repositorio Git, los ejecutará y obtendrá los resultados.  Más información sobre Jenkins.

La arquitectura planteada nos permitirá de forma sencilla escalar el número de dispositivos. Si no queremos montar una aplicación para gestionar la ejecución de las pruebas, Jenkins puede sernos de gran ayuda, ya que mediante sus plugin nos permitirá ejecutar los proyectos y obtener los resultados.

Levantando los servidores Appium

En este post no vamos a hablar de como montar la arquitectura planteada, pero si vamos a tratar de levantar un servidor de appium para dispositivos android, en el que poder ejecutar nuestras pruebas.

Lo cierto es que la instalación de appium es muy sencilla, en mi caso haré la instalación en un Ubuntu:
Distributor ID: Ubuntu
Description: Ubuntu 16.04.1 LTS
Release: 16.04
Codename: xenial

  1. Debemos tener instalado node ya podemos isntalar appium:
    # npm install -g appium
    # npm install wd
  2. Para levantar el servidor de appium únicamente hay que ejecutar el comando: appium
    Ojo, la última versión de appium contiene una versión de chromedriver incompatible con la última versión de chrome por lo que es necesario descargar a nuestro servidor la última versión de chromedriver y ejecutar appium con ese driver, mediante:
    # appium --chromedriver-executable [PATH CHROMEDRIVER]

Ya tendremos listo nuestro servidor de appium y a la escucha de peticiones.

Preparar y conectar el entorno Android

 

  1. Para poder lanzar las pruebas y conectar el dispositivo es necesario que tengamos instalado Android SDK en el servidor. En mi caso he descargado únicamente las librerías SDK, pero podéis acceder a la página oficial y descargaros android studio. En cualquier caso en internet hay una cantidad importante de blogs de como instalarlo.
  2. Una vez que lo tengamos instalado podemos conectar nuestros dispositivos físicos al servidor. Únicamente hay que conectarlos vía USB y ejecutar el siguiente comando, que levantará el servicio:
    # adb devices
    List of devices attached
    * daemon not running. starting it now on port 5037 *
    * daemon started successfully *
    XXXXXXXXXX device

Construyendo nuestro proyecto de pruebas

Mediante los pasos anteriores ya hemos levantado el servidor appium y conectado los dispositivos sobre los que lanzaremos las pruebas. El siguiente paso es crear el proyecto de pruebas.

github

 

En el siguiente enlace podéis descargar el proyecto de pruebas de GitHub. Es importante recalcar que el proyecto está desarrollado en Groovy haciendo uso del framework de testing Spock.

 

Vamos a comentar las partes más importantes del proyecto:

Configuración de entornos en environment.groovy

En el fichero environment.groovy vamos a definir los datos de los diferentes dispositivos que van a formar parte de nuestra granja de dispositivos:

  • Device: El nombre del dispositivo. Cuando hemos lanzado el comando “adb devices” nos ha listado los diferentes dispositivos conectados.
  • Platform: La plataforma en la que se lanzan las pruebas. En el siguiente enlace podéis ver todas las plataformas permitidas.
  • Browser: Navegador sobre el que se van a lanzar las pruebas. En el siguiente enlace podéis ver el listado de navegadores permitidos.
  • Server: URL del servidor appium. En este caso son servidores locales, pero si fueran remotos sería la URL remota. He añadido el parámetro dependiente de cada dispositivo debido a que cada dispositivo puede estar en un servidor diferente, no necesariamente en el mismo. Vamos a tomar los dispositivos como entornos independientes.

Configuración de entornos en Build.gradle

Una de las características más importantes que hemos definido en nuestra arquitectura es la disposición de diferentes dispositivos sobre lo que lanzar las pruebas. Para ello tenemos que dotar al proyecto de la capacidad de ejecutar las pruebas en cualquier entorno.

Para ello en el fichero build.gradle vamos a añadir las siguientes lineas:

  1. Mediante el método loadConfiguration obtendremos los datos del dispositivo donde ejecutaremos la prueba del fichero, que se encuentran definidos en el fichero environment.groovy.
  2. Una vez que se hayan obtenido los datos, estos se reemplazarán en el fichero test/groovy/resources/device.properties mediante la tarea processTestResources, que reemplazará los valores de los tokens definidos entre dos @.
    Podéis seguir el siguiente enlace para más información de como hacer uso de replaceTokens.

Clases de prueba (Specs)

En la fase de configuración del test (setup) vamos a obtener las propiedades del fichero device.properties para crear el objeto capabilities, donde se definen los datos del dispositivo en que ejecutaremos las pruebas. WebDriver será el objeto encargado de mandar los comandos o las ordenes al servidor de appium.

Eliminaremos la instancia del driver cuando se finalice la prueba en el paso cleanup().

Por lo que al test respecta, en este caso un test muy sencillo, únicamente hay que hacer uso del driver de selenium.

 

Ejecutando las pruebas

Para ejecutar las pruebas vamos a tener que cambiar un poco el flujo de trabajo de las tareas de gradle. Normalmente cuando ejecutamos un test de un proyecto gradle lo ejecutamos de la siguiente manera:

# gradle test

Ahora vamos a tener que ejecutar otras tareas con anterioridad para que genere el build del proyecto con los datos del entorno sobre el que queremos ejecutar las pruebas:

# gradle clean build -Penv=android1 test

  1. clean: Limpiaremos el directorio build para que genere uno nuevo.
  2. build -Penv=android1:  Environment definido en el fichero environment.groovy. De donde cogerá los datos para generar el build.
  3. test: Lanzar los teses del proyecto.

Conclusiones

Cada vez es mayor la gente que accede a nuestras aplicaciones webs mediante dispositivos móviles, por lo que cada vez tiene que ser mayor la tendencia de implementar pruebas móviles.

Si bien es cierto que lanzar pruebas sobre dispositivos reales es costoso, creo que es necesario invertir dinero y esfuerzos dado que las pruebas sobre dispositivos virtuales no nos van a dar la misma seguridad al no ser del todo reales.

Como hemos visto en el post, podemos montar una infraestructura de pruebas sencilla con varios dispositivos. Aún así si lo que queremos es disponer de una granja de dispositivos y despreocuparnos de la gestión de la misma, siempre podemos mirar algún servicio como el que ofrece Amazon AWS.

Referencias

  1. http://appium.io/
  2. https://docs.gradle.org/current/userguide/working_with_files.html#filterOnCopy
  3. https://chrislormor.wordpress.com/2013/10/27/customizing-gradle-builds-for-different-environments/

Dejar un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *