Cómo automatizar pruebas de software

Cuando empecé a dedicarme al testing automatizado, allá por el 2007, había una línea muy marcada entre los testers que trabajaban solamente haciendo testing manual y los que hacían solamente automatización o performance. Actualmente, sin embargo, esa línea no existe o está tendiendo a desaparecer ya que hoy un tester necesita, mucho más que antes, conocer a fondo el funcionamiento del software bajo prueba. De hecho, no está bien la diferenciación de arriba, ya que todo es testing, por lo tanto, así como un tester que no sabe automatizar debería aprenderlo, también un tester que hace automatización debería aprender a hacer testing manual si no lo sabe.

Si te interesa aprender, te invito a unirte al grupo Testing Automatizado en facebook.

escritorio de pc

¿Qué es la automatización de pruebas de software?

La automatización de pruebas de software es una disciplina que hace uso de diferentes herramientas para lograr que un sistema actúe simulando la interacción de un humano con el software que queremos testear, a modo de poder validar su comportamiento.

Por ejemplo, supongamos que tenemos una aplicación cualquiera, la cual permite buscar artículos a la venta de acuerdo a diferentes categorías, como ser: ropa, libros, tecnología, etc. Esta aplicación necesita ser probada, sobre todo cuando se realizan cambios, para asegurarnos de que todo sigue funcionando como debería. Por ejemplo: si hago una busqueda de “botas” en la categoría libros, no debería mostrar resultados de calzado, pero sí el libro del gato con botas.

Una de las formas de testear esta funcionalidad, es tomar un teléfono celular (si es una app) o un navegador web y hacer los pasos necesarios:

  1. Ingresar en la app.
  2. Buscar artículos.
  3. Validar los resultados.

A su vez, es recomendable probar diferentes combinaciones, por ejemplo: otras categorías, artículos no existentes, etc. A estas combinaciones también les tenemos que sumar otras que dependen del entorno de ejecución, es decir, si es una app de teléfonos móviles, deberíamos probar en iOS y Android y a su vez, con diferentes versiones de los mismos, así como distintas combinaciones de modelos de equipos, etc, para asegurarnos de que la búsqueda funciona bien siempre, sin importar qué sistema utilice el usuario.

Parece mucho, no? Bueno, de hecho lo es, sumado a que tendremos que repetir esto cada vez que el equipo necesite sacar una nueva versión de la app, incluso muchas veces en un mes, y sin contar que esto es una sola funcionalidad en una app que puede tener decenas.

Ahí es donde la automatización entra en juego, es decir, si nosotros tenemos que hacer una tarea N veces durante mucho tiempo, es más seguro y económico automatizarla para que se haga sola, sin interacción humana, y que nos avise si hay un error.

¿Cuándo se deben automatizar las pruebas de software?

No siempre es recomendable automatizar pruebas de software, ya que hay condiciones donde esto no es necesario, como por ejemplo:

  • Software que esté en etapas muy tempranas de desarrollo.
  • Validaciones difíciles o poco confiables para realizar con una computadora.
  • Software muy cambiante en el tiempo, con requerimientos poco claros.
  • Pruebas que no se van a ejecutar más que unas pocas veces.
  • Proyectos de muy corta duración.

Es decir, no queremos invertir tiempo y dinero en automatizar algo que en dos semanas va a cambiar (porque eso implica modificar o desarrollar nuevamente la automatización); o pruebas que se van a ejecutar pocas veces (ya que automatizar tiene un costo inicial que nos retorna un valor recién en el mediano plazo).

Ahora bien, si las condiciones de arriba no se cumplen, es decir, si tenemos un software relativamente estable, en un proyecto de larga duración y con una línea de desarrollo establecida, podemos decir que tenemos las condiciones dadas para automatizar nuestras pruebas.

¿Cuáles son las ventajas de automatizar nuestras pruebas?

Las ventajas de automatizar pruebas son variadas, por ejemplo la repetibilidad de las mismas, reduciendo errores de ejecución, ya que un sistema programado a realizar una tarea N veces es mas confiable que un humano haciendo la misma tarea repetidas veces.

A su vez, la velocidad es otro factor importante, ya sea porque las pruebas automatizadas pueden ejecutarse las veces que queramos, en los horarios que queramos, o porque la ejecución de las mismas es de por sí más rápida.

La confiabilidad de las mismas también aumenta, ya que podemos lanzar las mismas pruebas con la confianza de que siempre se van a ejecutar de la misma manera, con los mismos pasos y a su vez recolectando la evidencia que necesitemos, como capturas de pantalla o videos.

¿Qué debo saber antes de aprender a automatizar pruebas de software?

La automatizacion de pruebas, requiere ciertos conocimientos previos, sin los cuales va a ser imposible aprender a automatizar. Lamentablemente, no podemos empezar si no sabemos programar de antemano, ya que automatizar es programar.

¿Qué lenguaje de programación necesito para empezar a automatizar?

Hoy el mercado esta cubierto en un gran porcentaje por un grupo relativamente chico de frameworks de automatización, tales como: Selenium Webdriver, Appium, Expresso, etc, y los lenguajes que podemos utilizar son variados, tales como: Java, Python, Javascript, Ruby o C#.

¿Qué nivel necesito tener para empezar a automatizar?

La respuesta a esta pregunta es amplia, y va desde un nivel básico de programación orientada a objetos, hasta niveles más avanzados, dependiendo de lo que queramos hacer. Esto abarca desde la creación de casos de prueba utilizando pasos pre establecidos, hasta la creación de frameworks complejos de automatización que corran tests en paralelo, que interactúen con sistemas de integración continua o otras herramientas de reporte y gestión de dependencias.

¿Qué opciones hay para empezar?

Personalmente recomiendo empezar con alguna herramienta open source, como Selenium Webdriver, principalmente porque nos permite empezar sin atarnos a ninguna empresa en particular, además de que es sin lugar a dudas, la más usada del mercado, junto con su primo cercano, Appium, para pruebas en celulares y tabletas.

Otra de las ventajas de Selenium es que puede ser utilizado con muchos lenguajes de programación, como: Java, Python, Javascript, .NET, etc., además de contar con una enorme comunidad que lo soporta.

Además, el ecosistema que lo rodea es muy amplio, ya que podemos extender el framework y sumar funcionalidades con innumerables herramientas, de probada calidad, como ser: TestNG, jUnit, Allure, etc.

Como vemos, Selenium es una herramienta muy flexible, con la que podemos aprender a automatizar casos sencillos en apenas minutos.

¿Entonces cómo empiezo?

start

Descargar lo necesario

En este ejemplo vamos a utilizar las siguientes herramientas:

  • Java como lenguaje
  • Eclipse como IDE
  • Maven como gestor de dependencias

Crear un proyecto Java

El primer paso es crear un proyecto Java, integrando Maven, para ello abrimos la consola, y escribimos el siguiente comando:

	mvn archetype:generate -DgroupId=com.elblogdesanti.selenium -DartifactId=seleniumdemo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Una vez ejecutado el comando deberíamos ver un mensaje de Build Success:

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------< org.apache.maven:standalone-pom >-------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] --------------------------------[ pom ]---------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:3.1.2:generate (default-cli) > generate-sources @ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:3.1.2:generate (default-cli) < generate-sources @ standalone-pom <<<
[INFO]
[INFO]
[INFO] --- maven-archetype-plugin:3.1.2:generate (default-cli) @ standalone-pom ---
[INFO] Generating project in Batch mode
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Old (1.x) Archetype: maven-archetype-quickstart:1.0
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: basedir, Value: D:\\Users\\santius\\Documents\\development\\eclipseWorkspace\\seleniumdemo
[INFO] Parameter: package, Value: com.elblogdesanti.selenium
[INFO] Parameter: groupId, Value: com.elblogdesanti.selenium
[INFO] Parameter: artifactId, Value: seleniumdemo
[INFO] Parameter: packageName, Value: com.elblogdesanti.selenium
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: D:\\Users\\santius\\Documents\\development\\eclipseWorkspace\\seleniumdemo\\seleniumdemo
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  2.257 s
[INFO] Finished at: 2020-03-31T19:05:00-07:00
[INFO] ------------------------------------------------------------------------

Ahora solo nos queda crear el proyecto para abrirlo en Eclipse, para eso nos movemos al directorio creado con el comando anterior (seleniumdemo) y ejecutamos:

mvn eclipse:eclipse

Deberíamos ver nuevamente un mensaje de éxito:

[INFO] Scanning for projects...
Downloading from central: <https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-compiler-plugin/3.1/maven-compiler-plugin-3.1.pom>
Downloaded from central: <https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-compiler-plugin/3.1/maven-compiler-plugin-3.1.pom> (10 kB at 42 kB/s)
Downloading from central: <https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-compiler-plugin/3.1/maven-compiler-plugin-3.1.jar>
Downloaded from central: <https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-compiler-plugin/3.1/maven-compiler-plugin-3.1.jar> (43 kB at 605 kB/s)
[INFO]
[INFO] --------------< com.elblogdesanti.selenium:seleniumdemo >---------------
[INFO] Building seleniumdemo 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] >>> maven-eclipse-plugin:2.10:eclipse (default-cli) > generate-resources @ seleniumdemo >>>
[INFO]
[INFO] <<< maven-eclipse-plugin:2.10:eclipse (default-cli) < generate-resources @ seleniumdemo <<<
[INFO]
[INFO]
[INFO] --- maven-eclipse-plugin:2.10:eclipse (default-cli) @ seleniumdemo ---
[INFO] Using Eclipse Workspace: D:\\Users\\santius\\Documents\\development\\eclipseWorkspace
[WARNING] Workspace defines a VM that does not contain a valid jre/lib/rt.jar: C:\\Program Files\\Java\\jre1.8.0_191
[INFO] Adding default classpath container: org.eclipse.jdt.launching.JRE_CONTAINER
[INFO] Not writing settings - defaults suffice
[INFO] Wrote Eclipse project for "seleniumdemo" to D:\\Users\\santius\\Documents\\development\\eclipseWorkspace\\seleniumdemo\\seleniumdemo.
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  2.275 s
[INFO] Finished at: 2020-03-31T19:09:18-07:00
[INFO] ------------------------------------------------------------------------

Y ahora compilamos el proyecto para ver que este todo bien:

mvn install

Listo, ya tenemos el proyecto creado, ahora podemos importarlo en Eclipse.

Importar el proyecto Maven en Eclipse

Para importar el proyecto creado anteriormente, solamente tenemos que abrir Eclipse y navegar en el menu File –> Open projects from filesystem, donde seleccionamos la carpeta seleniumdemo creada por maven e importamos el proyecto.

Una vez importamos el proyecto, nos resta agregar la dependencia de Selenium en nuestro archivo POM, para ello abrimos el archivo y agregamos lo siguiente:

<!-- <https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-java> -->
<dependency>
    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <version>3.141.59</version>
</dependency>

De forma tal que el archivo completo debería quedar así:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="<http://maven.apache.org/POM/4.0.0>"
	xmlns:xsi="<http://www.w3.org/2001/XMLSchema-instance>"
	xsi:schemaLocation="<http://maven.apache.org/POM/4.0.0> <http://maven.apache.org/xsd/maven-4.0.0.xsd>">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.elblogdesanti.selenium</groupId>
	<artifactId>seleniumdemo</artifactId>
	<packaging>jar</packaging>
	<version>1.0-SNAPSHOT</version>
	<name>seleniumdemo</name>
	<url><http://maven.apache.org></url>

	<properties>
		<maven.compiler.target>1.8</maven.compiler.target>
		<maven.compiler.source>1.8</maven.compiler.source>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
		</dependency>
		<dependency>
			<groupId>org.seleniumhq.selenium</groupId>
			<artifactId>selenium-java</artifactId>
			<version>3.141.59</version>
		</dependency>
	</dependencies>
</project>

Y en eclipse deberíamos tener la siguiente estructura de archivos:

https://s3-us-west-2.amazonaws.com/secure.notion-static.com/4091d62d-0dc1-4486-86ac-4ddcfa8e4b3f/001.png

A partir de ahora vamos a trabajar sobre el paquete com.elblogdesanti.selenium que esta dentro de src/main/java, que debería haber quedado de la siguiente manera:

package com.elblogdesanti.selenium;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        System.out.println( "Hello World!" );
        
    }
}

Nuestro primer test en selenium

Lo primero que vamos a hacer antes de empezar a escribir el test, es descargar el driver para el navegador que vayamos a usar, en este caso, voy a utilizar Chrome, por lo que descargo el driver desde este enlace, de acuerdo a la versión de chrome que vaya a utilizar, y luego agregamos la ruta donde tengo el driver descargado a la variable path del sistema.

codigo

Para nuestro test vamos a hacer algo muy simple, usando este sitio para las pruebas, vamos a ejecutar los siguientes pasos:

  1. Ingresar a http://elblogdesanti.com
  2. Hacer click en el ícono de búsqueda
  3. Escribir “La regla de los dos minutos” en el campo de busqueda que aparece
  4. Hacer click en el boton de buscar

Para ello, vamos a utilizar las herramientas que Selenium Webdriver nos ofrece, en este caso, ingresar a un sitio, encontrar elementos, escribir textos y hacer click, tal como lo haria un humano que quiera probar la funcionalidad de busqueda a mano:

package com.elblogdesanti.selenium;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

/**
 * Hello world!
 *
 */
public class App 
{
	
    public static void main( String[] args )
    {
    	WebDriver driver = new ChromeDriver();
        driver.get("<http://elblogdesanti.com>");
        driver.findElement(By.className("cs-icon-search")).click();
        driver.findElement(By.className("search-field")).sendKeys("la regla de los dos minutos");
        driver.findElement(By.className("search-submit")).click();
    }
}

Una vez que tenemos esto, ejecutamos el proyecto y podemos ver cómo funciona Selenium Webdriver:

Consideraciones

La intención de este post es dar una introducción muy breve pero funcional al testing automatizado, en este caso utilizando Selenium Webdriver, con un test muy sencillo. Cabe destacar que en pos de la simplicidad no se están utilizando las mejores prácticas, como el uso del patrón de diseño PageObject o la inclusión de otras herramientas como TestNG o jUnit, ni assertions o reportes. Todo esto es algo que podemos llegar a ver en otros posts sobre automatización de software. Si tienen alguna consulta no duden en dejarla en comentarios.

gracias

Gracias por haberte tomado el tiempo de leer el post, espero que te haya sido de utilidad. Si te gustó te invito a leer la segunda parte, donde explico qué es testNG.

6 comments

Comments are closed.