Tema 1.6 - Práctica AutoIt

La práctica que se realizará a continuación es sobre una automatización en donde mezclaremos Selenium WebDriver para la interacción con la página web y AutoIt para automatizar las ventanas de Windows u otro elemento de Windows cuando sea necesario.

Lo que se hará con la automatización es simular el proceso de subida de un archivo ubicado localmente a internet.

En primer lugar, por medio de AutoIt se creará un archivo de Word en donde se ingresarán unas líneas de texto y finalmente se guardará en la misma ubicación en la que se encuentra el script de la automatización.

Luego con Selenium WebDriver se controlará la página web hasta el punto en el que se deba cargar el archivo a subir, la manipulación del cuadro de diálogo se realizará por medio de AutoIt para finalmente hacer la validación de la prueba.

Los conocimientos previos que se deben tener son los siguientes:

1. Selenium WebDriver.
2. Patrón de Diseño Page Object Model (POM).
3. Cucumber.
4. Serenity.
5. Gradle.
6. AutoIt.

Antes de crear nuestro proyecto Gradle en Eclipse, vamos a crear dos scripts de AutoIt que tendrán como nombres Crear Documento.au3 y Subir Archivo.au3, ambos archivos deben guardarse en el mismo lugar. En el primer script colocaremos el siguiente código:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <Word.au3>
#include <WordConstants.au3>

Local $oWord
Local $oDoc
Local $sNombreDoc = $CmdLine[1]

CrearDocumento()
IngresarTexto()
GuardarDocumento()
CerrarWord()

Func CrearDocumento()
	$oWord = _Word_Create()
	$oDoc = _Word_DocAdd($oWord)
EndFunc

Func IngresarTexto()
	WinActivate("Documento1 - Word")
	Send("Curso{SHIFTDOWN}.{SHIFTUP} AutoIt.")
	Send("{ENTER}")
	Send("Módulo IV.")
	Send("{ENTER}")
	Send("Q-Vision Technologies.")
	Send("{ENTER}")
	Send("Ejercicio práctico de automatización utilizando AutoIt.")
EndFunc

Func GuardarDocumento()
	_Word_DocSaveAs($oDoc,@ScriptDir&"\"&$sNombreDoc,$WdFormatDocumentDefault)
EndFunc

Func CerrarWord()
	_Word_Quit($oWord)
EndFunc

En la línea 6, la variable $sNombreDoc se le asigna la variable $CmdLine[1]. $CmdLine es un arreglo que en cada posición recibe un valor que le pasamos desde la línea de comando (CMD) o podemos hacerlo desde Java utilizando la clase ProcessBuilder que nos permite crear procesos del sistema operativo.

Nota: El elemento de $CmdLine en la posición 0 representa el número de valores que se enviaron desde ProcessBuilder.

En la línea 30, se utiliza la macro @ScriptDir para guardar el documento en la misma ruta en donde tenemos nuestro script que llamaremos Crear Documento.au3, luego le concatenamos el nombre de nuestro documento, le añadimos el formato .docx con la constante de Word $WdFormatDocumentDefault y, por último, convertimos nuestro script en un ejecutable.

Ahora en el script Subir Archivo.au3 escribimos el siguiente código:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

Local $nombraArchivo = $CmdLine[1]

RutaArchivo()
EscribirNombreArchivo()
Aceptar()

Func RutaArchivo()
	Sleep(1000)
	ControlFocus("Abrir","","[CLASSNN:ToolbarWindow323]")
	ControlClick("Abrir","","[CLASSNN:ToolbarWindow323]","right")
	Send("{DOWN 3}")
	Send("{ENTER}")
	Send("{BS}")
	Send(@ScriptDir)
	Send("{ENTER}")
EndFunc

Func EscribirNombreArchivo()
	Sleep(1000)
	ControlFocus("Abrir","","[CLASSNN:Edit1]")
	ControlSetText("Abrir","","[CLASSNN:Edit1]",$nombraArchivo)
EndFunc

Func Aceptar()
	ControlClick("Abrir","","[CLASSNN:Button1]")
EndFunc

En la línea 1 la variable $nombreArchivo recibe el nombre del archivo que vamos a subir a la internet, este nombre lo pasamos desde el código de Java utilizando la clase ProcessBuilder.

Convertimos el script Subir Archivo.au3 en un ejecutable para poder utilizarlo más adelante.

Ahora abrimos el IDE de Eclipse y procedemos a crear nuestro proyecto de Gradle. Para hacer esto le damos clic en File -> New -> Project.

Nos sale una ventana donde podemos elegir el tipo de proyecto que queremos crear, en este caso escogemos Gradle y le damos clic en el botón “Next”.

En la ventana New Gradle Project, colocamos como nombre del proyecto “practicaAutoIt”, dejamos la ruta por defecto donde se estará ubicada nuestro proyecto y le damos clic en el botón “Finish”.

Al finalizar, veremos en la pestaña Package Explorer nuestro proyecto creado.

Antes de continuar con los pasos para terminar de crear y configurar nuestro proyecto, vamos a explicar algunas partes de él.

• src/main/java: En esta parte se colocan todo lo que no esté relacionado con las pruebas, como, por ejemplo: las clases que van dentro de los paquetes models, pages, steps, etc.
• src/test/java: En este directorio ponemos las clases y paquetes que están relacionadas con la prueba como, por ejemplo: runners y stepdefinitions.
• src/test/resources: En esta ruta guardamos todos los recursos que necesitamos para la prueba como son los featrues y el driver (en esta práctica utilizaremos chromedriver).

Una vez explicado esto, seguimos con la configuración. En el proyecto que tenemos buscamos el archivo build.gradle, lo abrimos y quitamos el contenido que tiene por el siguiente:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

repositories {
	mavenLocal()
	jcenter()
}

buildscript {
	repositories {
		mavenLocal()
		jcenter()
	}
	dependencies {
		classpath("net.serenity-bdd:serenity-gradle-plugin:2.0.91")
	}
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'net.serenity-bdd.aggregator'

dependencies {
	testCompile 'net.serenity-bdd:serenity-core:2.0.91'
	testCompile 'net.serenity-bdd:serenity-junit:2.0.91'
	testCompile('junit:junit:4.12')
	testCompile('org.assertj:assertj-core:3.11.1')
	testCompile('org.slf4j:slf4j-simple:1.7.25')
	
	compile 'net.serenity-bdd:serenity-core:2.0.91'
	compile 'net.serenity-bdd:serenity-junit:2.0.91'
	compile 'net.serenity-bdd:serenity-cucumber:1.9.50'
}

tasks.withType(Test) {
	systemProperty 'tags', System.getProperty('tags', '')
}
gradle.startParameter.continueOnFailure = true

Una vez copiado, refrescamos gradle para empezar la descarga de las dependencias. Para lograr esto, le damos clic derecho al proyecto y seleccionamos Gradle -> Refresh Gradle Project.

Nota: En este paso es muy importante tener conexión a internet para poder descargar las dependencias.

Eliminamos la clase Library.java que se encuentra en el paquete practicaAutoIt de los directorios src/main/java y src/test/java. Después cambiamos el nombre del paquete practicaAutoIt de ambos directorios por co.com.fileuploader.

Luego, dentro del paquete co.com.file.uploader del directorio src/main/java creamos los subpaquetes pages y steps. Ahora en el paquete co.com.file.uploader del directorio src/test/java creamos los subpaquetes runners y stepdefinitions.

En el directorio src/test/resources creamos dos paquetes que tendrán como nombre feature y driver.

Colocamos en el paquete driver, el controlador que ejecutará nuestra prueba en un navegador en específico, como se mencionó antes, se piensa utilizará el driver chromedriver el cual puede conseguir en el siguiente enlace Descargar ChromeDriver.

Nota: Debe descargar el driver que sea compatible con la versión de su navegador Chrome.

Cuando tengamos el driver descargado, lo arrastramos hasta el paquete driver de nuestro proyecto y lo soltamos.

Ahora creamos nuestra historia de usuario que vamos a probar, entonces le damos clic derecho en el proyecto y seleccionamos New -> File. En la ventana Create New File buscamos la ruta hacia nuestro paquete feature que es src/test/resources/feature, luego en el nombre del archivo colocamos fileuploader.feature y para finalizar le damos clic en el botón Finish.

Nota: Si usted no tiene el plugin de Cucumber instalado le saldrá un mensaje para ver si lo desea instalar o desea un utilizar un editor de texto, le recomendamos que instale el plugin.

Cuando tenga el archivo fileuploader.feature creado, copie la siguiente historia en formato Gherkin.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#Author: Q-Vision Technologies
#language: es
Característica: Subir Archivo
  Como usuario del sistema
  Quiero cargar un archivo a la Internet
  Para poder tenerlo en la red

  Escenario: Cargar Archivo
    Dado que se crea el archivo de Word "Práctica AutoIt"
    Cuando ingrese al sitio web
    Y escoja el archivo "Práctica AutoIt.docx" para cargar a la Internet
    Entonces debería ver el archivo "Práctica AutoIt.docx" subido

Vemos que como utilizamos Gherkin en español, hay ciertos caracteres como las tildes que cuando Cucumber haga la traducción del lenguaje Gherkin al de programación arrojará un error ya que nuestro IDE Eclipse no está configurado para entender estos caracteres, para solucionar esto nos dirigimos a la barra de menú de Eclipse y seleccionamos Window -> Preferences. En la nueva ventana que nos aparece (Preferences) le damos clic en el signo “mayor que” que trae General para que se nos desgloce todas las opciones de éste, luego damos clic en la opción Workspace y en esta sección buscamos el apartado Text file encoding, seleccionamos la opción Other y por último en la lista desplegable escogemos la que dice UTF-8. Una vez hecho esta configuración le damos en el botón Apply y después en Apply and Close para guardar los cambios efectuados.

Si se utiliza Gherkin en inglés (por defecto) no habría necesidad de hacer esta configuración.

Ahora vamos a crear el archivo serenity.properties que nos permitirá ingresar una serie de parámetros para personalizar la manera en la que se va a ejecutar la prueba. Para crear este archivo le damos clic derecho al proyecto y seleccionamos New -> Unititled Text File. Se nos abrirá un archivo y en él escribimos las siguientes líneas:

1
2
3
4
5
6
7
8
9

serenity.project.name = Práctica AutoIt
webdriver.driver = chrome
webdriver.chrome.driver = src/test/resources/driver/chromedriver.exe
serenity.take.screenshots.for.interactions = FOR_FAILURES
serenity.reports.show.steps.details = true
serenity.tiemout = 20000
webdriver.wait.for.timeout = 20000
webdriver.timeouts.implicitlywait = 20000
chrome.switches = --start-maximized, --test-type

Cuando queramos guardar el archivo nos saldrá una ventana en donde elegimos la carpeta padre donde se alojará este archivo que será practicaAutoIt y el nombre que le vamos a poner al archivo que es serenity.properties.

A continuación, daremos una breve explicación de cada línea del archivo “serenity.properties”.

1. Nombre que se visualizará en los reportes.
2. Indica el navegador con el que se quiere correr las pruebas.
3. Ruta en donde se encuentra el driver.
4. Este parámetro puede obtener varios valores que nos permite establecer cómo son tomadas las evidencias. En este caso le decimos que tome evidencias cuando haya fallas.
5. Muestra información detallada de la tabla de resultados. Si es verdadero la tabla mostrará un desglose de resultados por steps. Este valor es falso por defecto.
6. Indica el tiempo que el driver esperará por elementos no visibles de forma inmediata. El valor que recibe está en milisegundos.
7. Tiempo que espera el driver cuando se usa un método de espera. Acepta un valor en milisegundos.
8. Tiempo que espera el driver a que aparezcan los elementos por defecto. El valor que recibe está en milisegundos.
9. Hace que el navegador empiece con la pantalla maximizada y de tipo prueba.

Después de esto crearemos la clase FileUploaderRunner en el paquete runners, para que se encargue de ejecutar el feature fileuploader.feature. En esta clase copiamos el siguiente código:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

package co.com.fileuploader.runners;

import org.junit.runner.RunWith;

import cucumber.api.CucumberOptions;
import cucumber.api.SnippetType;
import net.serenitybdd.cucumber.CucumberWithSerenity;


@RunWith(CucumberWithSerenity.class)
@CucumberOptions(
	features = "src/test/resources/feature/fileuploader.feature",
	glue = "co.com.fileuploader.stepdefinitions",
	snippets = SnippetType.CAMELCASE
		
)

public class FileUploaderRunner {

}

Luego en el paquete stepdefinitions creamos la clase FileUploaderStepDefinitions que describirá el “qué” está haciendo nuestra prueba. Cuando tengamos la clase copiamos las siguientes líneas de código:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

package co.com.fileuploader.stepdefinitions;

import java.io.IOException;

import co.com.fileuploader.steps.SFileUpload;
import cucumber.api.java.es.Cuando;
import cucumber.api.java.es.Dado;
import cucumber.api.java.es.Entonces;
import cucumber.api.java.es.Y;
import net.thucydides.core.annotations.Steps;

public class FileUploaderStepDefinitions {
	
	@Steps
	SFileUpload sFileUpload;
	
	@Dado("^que se crea el archivo de Word \"([^\"]*)\"$")
	public void queSeCreaElArchivoDeWord(String nombreArchivo) {
	   this.crearDocumento(nombreArchivo);
	}

	@Cuando("^ingrese al sitio web$")
	public void ingreseAlSitioWeb() {
	    sFileUpload.ingresarSitioWeb();
	}

	@Y("^escoja el archivo \"([^\"]*)\" para cargar a la Internet$")
	public void escojaElArchivoParaCargarALaInternet(String nombreArchivo) {
	   sFileUpload.buscarArchivo(nombreArchivo);
	}

	@Entonces("^debería ver el archivo \"([^\"]*)\" subido$")
	public void deberíaVerElArchivoSubido(String nombreArchivo) {
		sFileUpload.verificarArchivoSubido(nombreArchivo);
	}
	
	private void crearDocumento(String nombreArchivo) {
		String rutaEjecutable = "C:\\Users\\QV2935\\Downloads\\Crear Documento.exe";
		ProcessBuilder pb = new ProcessBuilder(rutaEjecutable, nombreArchivo);
		try {
			pb.start();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
}

A continuación, explicaremos algunas líneas del código anterior:

1. En la línea, 19 llamamos el método crearDocumento la cual se encargará de crear y guardar nuestro documento de Word.
2. En la línea 38, la variable rutaEjecutable se le asigna un string que es la ubicación de nuestro ejecutable Crear Documento. Usted debe colocar la ruta en donde se encuentra su ejecutable.
3. En la línea 39, se crea el objeto pb de tipo ProcessBuilder que se utiliza para crear un proceso. En la declaración del objeto pasamos dos parámetros, el primero es la ruta hacia nuestro ejecutable Crear Documento, y el segundo es el nombre que se le pondrá al documento de Word que el ejecutable lo recibirá mediante la variable $CmdLine.
4. En la línea 41 utilizamos el método start() para iniciar el ejecutable.

Nos saldrá algunos errores debido a que ni todavía hemos creado la clase SFileUpload.

Ahora nos dirigimos al paquete steps y en ella creamos la clase SFileUpload donde copiamos el siguiente código:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

package co.com.fileuploader.steps;

import static org.junit.Assert.assertEquals;
import java.io.IOException;
import org.fluentlenium.core.annotation.Page;
import org.openqa.selenium.interactions.Action;
import org.openqa.selenium.interactions.Actions;
import co.com.fileuploader.pages.FileUpload;
import net.serenitybdd.core.pages.PageObject;
import net.thucydides.core.annotations.Step;

public class SFileUpload extends PageObject {
	
	@Page
	FileUpload pageFileUpload;
	
	@Step
	public void ingresarSitioWeb() {
		// espera de 4 segundos
		waitABit(4000);
		pageFileUpload.open();
		pageFileUpload.seccionUpload();
	}
	
	@Step
	public void buscarArchivo(String nombreArchivo) {
		String rutaEjecutable = "C:\\Users\\QV2935\\Downloads\\Subir Archivo.exe";
		ProcessBuilder pb = new ProcessBuilder(rutaEjecutable, nombreArchivo);
		Actions builder = new Actions(getDriver());
		Action moverMouse = builder.moveToElement(pageFileUpload
				.presionarEscogerArchivo())
				.click()
				.build();
		moverMouse.perform();
		try {
			pb.start();
		} catch(IOException e) {
			e.printStackTrace();
		}
		// espera de 4 segundos
		waitABit(4000);
		pageFileUpload.presionarUpload();
	}
	
	@Step
	public void verificarArchivoSubido(String nombreArchivo) {
		String nombreActual;
		nombreActual = pageFileUpload.conseguirNombreArchivo();
		assertEquals(nombreArchivo, nombreActual);
	}
}

Antes de avanzar explicaremos algunas líneas del código que se mencionó anteriormente.

1. En la línea 20, usamos el método waitABit() de la clase PageObject que recibe un entero como parámetro. Este método tiene como finalidad pausar la ejecución durante 4 segundos para AutoIt pueda crear nuestro archivo de Word, guardarlo y posteriormente cerrarlo.
2. En la línea 27, a la variable rutaEjecutable se le asigna una cadena de caracteres que es la ruta hasta el ejecutable Subir Archivo. Debe cambiar este string con la ruta en donde usted tiene ubicado este archivo.
3. En la línea 28, creamos el objeto pb de tipo ProcessBuilder. En la declaración del objeto pasamos dos parámetros que son la ubicación del ejecutable Subir Archivo y el nombre del archivo de Word que queremos que AutoIt busque y subar a la internet.
4. Desde la línea 29 hasta la 34 simulamos el movimiento del mouse hasta el objeto que queremos y posteriormente le damos clic. Todo esto lo logramos usando los métodos que tienen las clases Action y Actions.
5. En la línea 36, usamos el método start() para iniciar el ejecutable Subir Archivo y nos seleccione el archivo de Word que tenemos almacenado en el ordenador.
6. En la línea 41 hacemos otra espera de 4 segundos para que la ejecución de Selenium WebDriver se pause mientras que AutoIt automatiza el proceso de encontrar y seleccionar el archivo de Word que queremos subir a la internet.

Notamos que cuando copiamos el código nos aparecerá errores y esto se debe a que no tenemos implementado la clase FileUpload en nuestro proyecto.

Como penúltimo paso para tener listo el proyecto, en el paquete pages creamos la clase FileUpload. Esta clase contendrá todos los elementos de la página web con las que vamos a interactuar para lograr subir el documento.

Cuando creemos la clase procedemos a copiar el siguiente código:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package co.com.fileuploader.pages;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;

import net.serenitybdd.core.annotations.findby.FindBy;
import net.serenitybdd.core.pages.PageObject;
import net.serenitybdd.core.pages.WebElementFacade;
import net.thucydides.core.annotations.DefaultUrl;

@DefaultUrl("http://the-internet.herokuapp.com/")
public class FileUpload extends PageObject {
	
	@FindBy(xpath = "(//ul//li//a)[18]")
	WebElementFacade enlaceFileUpload;
	
	@FindBy(id = "file-submit")
	WebElementFacade btnUpload;
	
	@FindBy(id = "uploaded-files")
	WebElementFacade textoArchivo;
	
	public void seccionUpload() {
		enlaceFileUpload.waitUntilPresent().click();
	}
	
	public String conseguirNombreArchivo() {
		return textoArchivo.getText();
	}
	
	public WebElement presionarEscogerArchivo() {
		return getDriver().findElement(By.id("file-upload"));
	}
	
	public void presionarUpload() {
		btnUpload.waitUntilClickable().click();
	}
	
}

El proyecto quedará con la siguiente estructura:

Con esta clase ya no tendremos errores en ninguna parte de nuestro proyecto. Ahora para finalizar tenemos que ejecutar nuestra prueba y para ello nos dirigimos a la clase FileUploaderRunner le damos clic derecho y seleccionamos Run As -> JUnit Test.

Si todo se configuró correctamente debería mostrar la siguiente imagen indicando que la prueba pasó exitosamente y también debería tener un archivo de Word con nombre Práctica AutoIt en el mismo lugar donde tiene los scripts de AutoIt.

En el siguiente video se muestra la ejecución la prueba.