Mostrando entradas con la etiqueta QA. Mostrar todas las entradas
Mostrando entradas con la etiqueta QA. Mostrar todas las entradas

Automatizaciones en Android con Selenium II


1 – Introducción

En este documento voy a mostrar como lanzar automatizaciones en un dispositivo móvil con android, que puede ser teléfono o tablet y con eclipse elaboraremos un script que por medio de Selenium II será ejecutado en el dispositivo.

Los elementos que vamos a utilizar para este tutorial serán los siguientes:

-        Dispositivo móvil con Android y el USB (En mi caso es un Motorola XT300) o puede ser un emulador que lo encontramos dentro del SDK que descargaremos.
-        Android SDK (http://developer.android.com/sdk/index.html) Incluye Eclipse
-        Android Server APK (http://code.google.com/p/selenium/downloads/list)
-        Librerias de Selenium - Java (http://seleniumhq.org/download)
-        Conexion WIFI a internet

 2 – Integración de ADB

Descargamos Android SDK y lo descomprimimos. Copiamos la carpeta SDK y Eclipse y la pondremos en el disco C (Creandole una carpeta para alojar a ambos)
En mi caso los metí dentro de una carpeta llamada android y me quedo en esta ruta:

c:\android

Lo que sigue ahora es definir la variable de entorno. Para que el equipo me reconozca el adb que viene dentro del SDK.

Para ello vamos a:

Inicio >> Panel de control >> Sistema >> Configuraciones avanzadas del sistema

Una vez ahí dentro, nos dirigimos a la pestaña Avanzada >> Variables de entorno

Editamos el PATH y colocamos la ruta en la que copiamos el SDK. Deberíamos tener algo como esto:



Añadimos un punto y coma después de la ultima ruta, colocando la nuestra. En mi caso es

c:\android\sdk\platform-tools

Si todo quedo correcto, deberíamos poder colocar “adb” en una consola y debería traer los parámetros del mismo

Inicio >> cmd >> adb



Si llegamos hasta acá, quiere decir que todo está perfecto. De lo contrario, lo más seguro es que este mal definido el PATH.

3 – Instalación de drivers USB

Tomamos nuestro dispositivo móvil y vamos a activar el modo de depuración

Configuraciones >> Aplicaciones >> Desarrollo

Y tildamos “Depuración de USB”

Una vez hecho esto, conectamos el dispositivo a la PC y abrimos eclipse que está en la carpeta que creamos en el disco C.

Abrimos el Android SDK Manager y descargamos los USB Drivers. Al estar conectado el dispositivo móvil, identifica que drivers utiliza y descargara e instalara automáticamente los drivers necesarios.



Para saber si todo quedo bien instalado, abrimos una consola y tipeamos

adb devices

Y esto debería devolvernos un número de serie que es nuestro dispositivo conectado.


Si llegamos hasta acá, es por que venimos muy bien! En caso de lanzar error, es porque el driver del dispositivo, no fue bien instalado.

4 – Instalación de Android Server en el móvil

Abrimos una consola y nos paramos en el directorio en donde se encuentra el Android Server APK. Una vez ahi, escribimos la siguiente línea:

adb -s [serialId] -e install -r [APK]

En donde el serialId es el serial de nuestro dispositivo móvil y APK es el nombre con el cual descargaron el Android Server. Debería quedarles algo como esto:

adb -s 003089349226000000000000 -e install -r android-server-2.6.0.apk


Si nos aparece el Success como en la imagen, es porque quedo bien instalado.

Ahora iniciaremos la aplicación en el móvil con el siguiente comando

adb -s [serialId] shell am start -a android.intent.action.MAIN -n org.openqa.selenium.android.app/.MainActivity

Automáticamente, se iniciara en el móvil la aplicación WebDriver (recuerden reemplazar el SerialId por el de ustedes)


Finalmente seteamos el puerto de escucha con el siguiente comando

adb -s [serialId] forward tcp:8080 tcp:8080

5 – Creación del proyecto e importación de librerías

Abrimos eclipse y creamos un nuevo proyecto.

File >> New >> Java Project


Asignamos un nombre al proyecto y una ubicación, seguido a esto, damos click en Next.

Vamos a la pestaña de librerías y pulsamos el boton Add External JARs...

Añadimos la librería de android.jar que está dentro de:

sdk >> platforms >> android-4.2

Y las de selenium que descargamos


Finalmente clickeamos en Finish

6 – Ejecutando nuestro primer Script

File >> New >> JUnit Test Case

Le colocamos un nombre y damos click en Finish


Borramos lo que tenemos dentro del cuadro de código y colocamos el siguiente:

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.android.AndroidDriver;


public class androidtest {
               
private static WebDriver driver;
   
    @Before
    public void setUp() {
        driver = new AndroidDriver();
       driver.get("http://underc0de.org");
    }
   
    @After
    public void tearDown(){
        driver.close();
        driver.quit();
    }

@Test

public void measurePerformance() throws InterruptedException {
    Thread.sleep(3000);
    driver.findElement(By.className("readViewMoreBtn")).click();

}
}


Ejecutamos el Test Case y podremos verlo en nuestro móvil. Al finalizar, nos mostrara el resultado si se corrió bien o mal.


7 – Emulando el ambiente de prueba

Presionamos el icono del dispositivo móvil (ADV) que está en el eclipse. Y crearemos un nuevo dispositivo



Le asignamos un nombre, elegimos la resolución de pantalla y la versión de android, luego damos click en ok.


Seleccionamos el emulador, presionamos Start y luego Launch, y se abrirá el emulador.


Una vez hecho esto, los pasos para lanzar la prueba son los mismos que la anterior, es decir, repetimos los pasos del punto 4, que eran los de instalar el andoird server en el móvil.

Finalmente, lanzamos el test con eclipse


Y con esto podremos hacer más scripts y lanzar las pruebas contra el emulador.

Espero que les haya gustado y les sirva.


ANTRAX


Testing de Performance con JMeter


Introducción: 
Resumiendo un poco, Los testing de performance permiten conocer el mal desempeño de alguna aplicación.
JMeter es uno de los programas más usados a la hora de hacer un testing de performance ya que es muy fácil de manejar. Carece de un buen reporte de resultados, pero aun así muestra todos los resultados necesarios para este tipo de testing.
JMeter se puede usar para aplicaciones que manejen estos protocolos:

Web – HTTP, HTTPS
SOAP
Database via JDBC
LDAP (Lightweight Directory Access Protocol)
JMS (Java Message Service)
Mail – POP3

Cabe aclarar que JMeter funciona con todos los navegadores.
Sin más nada que decir, empezaremos a usarlo.

Primeros pasos con JMeter
Empezaremos descargando JMeter de su página oficial: http://jmeter.apache.org/download_jmeter.cgi
Es una herramienta Open source y se darán cuenta cuando la descarguen.
Una vez descargada, la descomprimimos y vamos al directorio bin y ejecutamos el archivo llamado jmeter.bat y veremos una pantalla similar a la siguiente imagen:


Para comenzar, añadiremos un grupo de hilos, que es el que contendrá todos los pasos a testear.
Para ello vamos: 

Plan de Pruebas  >>  Añadir  >>  Hilos (Usuarios)  >>  Grupo de Hilos

  
Colocamos un nombre para identificarlo:


Como se puede ver, se puede aumentar el número de hilos, cada cuantos segundos queremos que se corran las iteraciones, etc.
Ahora crearemos un banco de trabajo. Para ello clickeamos sobre Banco de trabajo con el click derecho del mouse
Y nos dirigimos a:
Añadir  >>  Elementos NoDePrueba  >>  Servidor Proxy HTTP


Ahora configuraremos la conexión entre el programa y el navegador para que JMeter pueda recibir todo lo que se escucha por un puerto específico

 
Como se puede ver, el primer recuadro rojo es para el puerto, este mismo puerto es el que debemos colocar en nuestro navegador.
El segundo cuadro es para el Controlador Objetivo, en el cual pondremos el hilo que hemos creado en el plan de pruebas.
Como se pueden crear muchos hilos, debemos seleccionar cual es el que deseamos grabar en ese momento. Entonces todo lo que naveguemos quedara guardado en ese controlador de objetivo que seleccionemos.
Finalmente se puede excluir algunas extensiones. Yo en mi caso saque las imágenes, Pero eso ya es opcional.
Una vez que tengamos hecho eso, configuraremos el navegador. Yo usare Firefox.
Nos vamos a:
Herramientas  >>  Opciones

En las opciones avanzadas, vamos a la pestaña Red y entramos a las configuraciones de la conexión:


Seleccionamos la configuración manual del proxy, y en Proxy HTTP, colocamos localhost y en puerto, debemos poner el mismo que habíamos puesto en JMeter. Que en mi caso es el 8080.


Una vez que tenemos esto, damos aceptar.
Volvemos al JMeter y ahora presionamos en Arrancar para empezar a grabar los pasos.

Grabando los pasos

  
Ahora si podemos comenzar a navegar para guardar los pasos.


Una vez que finalizamos de hacer el recorrido de navegación, o los pasos a testear, frenamos el JMeter para dejar de grabar


Bueno, con esto ya hemos grabado todos los pasos. Ahora vamos a ver un poco los resultados
Si miramos en la izquierda, aparece el icono del hilo y con una chincheta que se puede abrir


Haciendo click en ella, podremos ver todos los pasos y todo lo que paso por entre medio al navegar.

 
Obteniendo resultados
Ahora solo nos queda ver en que tiempo responde la navegación y demás. Para ello, añadimos un reporte de resumen
Con el click derecho del mouse en Plan de Pruebas
Añadir  >>  Receptor  >>  Reporte Resumen


Y como podemos ver, se añade debajo del hilo


 Ahora solo nos queda correr el hilo y ver los resultados.


Damos click en Arrancar, que es el botón verde con el Play y esperamos los resultados


En el reporte podemos ver los valores de respuesta de cada elemento de la página, si hay porcentaje de error y demás.
Así como añadimos en este caso reporte de resumen, JMeter permite hacer graficas y otros reportes bastantes útiles que se añaden de la misma forma que el que acabamos de ver.
A demás como dije antes, se pueden añadir iteraciones para simular el ingreso de más de un usuario a la aplicación y ver como responde esta.
Espero que les haya gustado este paper y que les sea útil!

ANTRAX

Automatizacion Selenium IDE + Python


Introducción
 
Selenium IDE es un complemento de Firefox utilizado para automatizar y hacer pruebas sobre aplicaciones web.
Para ello, realiza una grabación de determinadas acciones que luego las convierte en un script editable. Lo más cómodo, es que luego este script se puede ejecutar tantas veces como se quiera.
La función principal de este plugin es poder hacer testing funcional de las aplicaciones. Permite rellenar formularios, navegar por webs, etc.
Esta herramienta permite ahorrar mucho tiempo y esfuerzo. Para ello permite automatizar pruebas que puede ser una prueba en particular o conjunto de pruebas.

Instalación
Solo basta con ir a http://seleniumhq.org/download/ y descargar Selenium IDE.


Nos aparecerá el cartel para instalar el complemento y solo damos en permitir


Y comenzara a descargarlo…


Una vez descargado, lo instalamos


Una vez instalado, nos pedirá que reiniciemos el browser

 

Y con esto ya quedara instalado. Podremos encontrar Selenium en el menú de Herramientas del navegador

  


A demás de esto, necesitaremos instalar python y la librería de selenium para python (en mi caso)
Librería de Selenium: http://pypi.python.org/pypi/selenium
Una vez instalado python, copiamos las librerías de Selenium dentro de la carpeta de las librerías (C:\Python27\Lib).

 
Primeros pasos con Selenium

Abrimos el navegador, yo usare firefox. Iniciamos Selenium IDE


Apenas lo abrimos, comenzamos a navegar normalmente y Selenium grabara todos los pasos que hagamos.
Mis pasos son los siguientes:
[+] Google
[+] ANTRAX-LABS
[+] Boton Buscar
[+] Click en el link de mi blog


Como se puede ver, Ya estoy en mi blog y Selenium grabo todos mis pasos


Ahora lo que hare, sera comprobar un enlace de mi blog, para ello, con el botón secundario del mouse, dare click en un enlace de mi blog y seleccionare “verifyElementPresent…”


Como se puede ver en la imagen, han quedado grabados todos los pasos que hice.


Ahora se puede exportar el script de automatización a cualquiera de los lenguajes que se ven en la imagen. Yo trabajare con Python.


Guardamos el script con su extensión correspondiente

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.common.exceptions import NoSuchElementException
import unittest, time, re

class TestAntraxLabs(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Firefox()
        self.driver.implicitly_wait(30)
        self.base_url = "http://www.google.com.ar/"
        self.verificationErrors = []
    
    def test_antrax_labs(self):
        driver = self.driver
        driver.get("/")
        driver.find_element_by_id("lst-ib").click()
        driver.find_element_by_id("lst-ib").clear()
        driver.find_element_by_id("lst-ib").send_keys("antrax-labs")
        driver.find_element_by_name("btnG").click()
        driver.find_element_by_link_text("[A]NTRAX [L]ABS").click()
        try: self.assertTrue(self.is_element_present(By.LINK_TEXT, "Seguridad Wireless"))
        except AssertionError as e: self.verificationErrors.append(str(e))
    
    def is_element_present(self, how, what):
        try: self.driver.find_element(by=how, value=what)
        except NoSuchElementException, e: return False
        return True
    
    def tearDown(self):
        self.driver.quit()
        self.assertEqual([], self.verificationErrors)

if __name__ == "__main__":
    unittest.main()
Y como resultado tendremos el script, que puede ser editable para añadir o modificar funciones

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.common.exceptions import NoSuchElementException
import unittest, time, re

class TestAntraxLabs(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Firefox()
        self.driver.implicitly_wait(30)
        self.base_url = "http://www.google.com.ar/"
        self.verificationErrors = []
    
    def test_antrax_labs(self):
        driver = self.driver
        driver.get(self.base_url)
        driver.find_element_by_id("lst-ib").click()
        driver.find_element_by_id("lst-ib").clear()
        driver.find_element_by_id("lst-ib").send_keys("antrax-labs")
        driver.find_element_by_name("btnG").click()
        driver.find_element_by_link_text("[A]NTRAX [L]ABS").click()
        try: self.assertTrue(self.is_element_present(By.LINK_TEXT, "Seguridad Wireless"))
        except AssertionError as e: self.verificationErrors.append(str(e))
    
    def is_element_present(self, how, what):
        try: self.driver.find_element(by=how, value=what)
        except NoSuchElementException, e: return False
        return True
    
    def tearDown(self):
        self.driver.quit()
        self.assertEqual([], self.verificationErrors)

if __name__ == "__main__":
    unittest.main()
Lo que hice acá, fue un ligero cambio. Reemplace la barra por la variable que contiene la url inicial, en mi caso la de google.


Si corremos el Script, se nos abrirá el navegador y automáticamente comenzara a navegar y a seguir los pasos que dejamos grabados.


Al finalizar, lanza un mensaje diciendo si paso o no la prueba. En mi caso busco y abrió mi blog correctamente y pudo verificar el enlace, en por eso que me dio el OK.
En caso de no pasar, tirara un mensaje de error.
Lo bueno de Selenium es que se puede trabajar en varios lenguajes y que sus scripts exportados son editables.