Los tests de aceptación son una simulación que nos sirve para saber que podemos pasar a producción nuestra nueva feature, estando seguros de que no hemos roto nada en otra parte del proyecto.

Básicamente, se trata de simular mediante un programita cómo se comportaría un usuario delante de nuestra web. Aunque hay muchas herramientas, la más usada es Selenium server. Se trata de un fragmento de código que tomará el control de nuestro navegador e irá navegando por patallas, rellenando cajas de texto o pulsando botones tal y como esperamos que lo haga una persona real.

Aunque la idea nos puede parecer muy interesante, he de reconocer que tener un servidor de Selenium funcionando y bien conectado a los navegadores de la máquina que lo alberga no es simple. Y ni hablar si además de eso queremos que corra en un entorno sin interfaz gráfica, como por ejemplo nuestro servidor de testeo.

En este post voy a tratar de explicar cómo montar un sistema como el anterior con un solo comando. Luego veremos nuestros primeros tests de aceptación.

Los pasos que vamos a seguir son:

  • Instalar el servidor de Selenium en una máquina remota.
  • Instalar test runner.
  • Escribir un test de aceptación.

Por desgracia, aquí no vamos a tratar profundamente cómo escribir correctamente test de aceptación, ya que eso llevaría mucho más que un simple post. Pero sí vamos a dejarlo todo listo para que nuestro equipo de QA pueda escribir todos los test que se consideren oportunos desde negocio.

(1) Instalar Selenium. Por simplicidad, voy a usar Vagrant para simular un servidor remoto. Sin embargo, no tendrás problemas si usas un Droplet de DigitalOcean con Docker preinstalado en lugar de una máquina virtual.

Creamos nuestro entorno de trabajo:

$ mkdir selenium
$ cd selenium
$ vagrant init

Hemos creado la carpeta que va a contener nuestro entorno de trabajo y dentro de ella nuestro fichero Vagrantfile. Lo abrimos y reemplazamos todo su contenido por lo siguiente:

Vagrant.configure(2) do |config|  
  config.vm.box = "phusion/ubuntu-14.04-amd64"
  config.vm.network "private_network", ip: "192.168.33.10"

  # config.vm.network "forwarded_port", guest: 80, host: 8080
  # config.vm.network "public_network"
  # config.vm.synced_folder "../data", "/vagrant_data"

  config.vm.provision "docker" do |d|
    d.run "selenium/standalone-chrome",
      daemonize: true,
      args: "-p 4444:4444 --name selenium",
      auto_assign_name: false
  end
end  

Las partes más importantes de la configuración son:

  • La creación una red privada en la IP 192.168.33.10
config.vm.network "private_network", ip: "192.168.33.10"  
  • Crear un container partiendo de la imagen de un servidor de Selenium
d.run "selenium/standalone-chrome",  

Este servidor tiene la peculiaridad de que carga un Chrome sin interfaz gráfica. Esto es ideal, si lo que deseamos es lanzar nuestros test de aceptación en un servidor y no en un entorno de escritorio.

  • Por último, exponemos el puerto que usará nuestro servidor 4444 a la máquina virtual creada por Vagrant.
args: "-p 4444:4444 --name selenium"  

Una vez tenemos nuestra configuración de Vagrant lista para ser usada, levantamos la máquina virtual:

$ vagrant up --provision
Bringing machine 'default' up with 'virtualbox' provider...  
==> default: Checking if box 'phusion/ubuntu-14.04-amd64' is up to date...
==> default: Clearing any previously set forwarded ports...
==> default: Fixed port collision for 22 => 2222. Now on port 2200.
==> default: Clearing any previously set network interfaces...
==> default: Preparing network interfaces based on configuration...
    default: Adapter 1: nat
    default: Adapter 2: hostonly
==> default: Forwarding ports...
    default: 22 => 2200 (adapter 1)
==> default: Booting VM...
==> default: Waiting for machine to boot. This may take a few minutes...
    default: SSH address: 127.0.0.1:2200
    default: SSH username: vagrant
    default: SSH auth method: private key
    default: Warning: Connection timeout. Retrying...
==> default: Machine booted and ready!
==> default: Checking for guest additions in VM...
==> default: Configuring and enabling network interfaces...
==> default: Mounting shared folders...
    default: /vagrant => /Users/carlosvillu/Desktop/blog/code/selenium-docker
==> default: Running provisioner: docker...
    default: Configuring Docker to autostart containers...
==> default: Starting Docker containers...
==> default: -- Container: selenium/standalone-chrome
....

Esto puede tardar un buen rato, sobre todo la primera vez, ya que tenemos que descargar todo lo necesario para tener nuestra imagen de Selenium.

Una vez haya terminado el proceso de Vagrant, deberíamos tener nuestro servidor up&running en la dirección 192.168.33.10:4444

(2) Instalar el test runner

$ npm install nightwatch
$ mkdir tests
$ touch nightwatch.json
$ touch tests/homePage.test.js

Como puedes ver, instalamos la libería NigthWatchJS para realizar los tests. Este es un test runner que se conecta a nuestro servidor de Selenium y es capaz de controlarlo. Si tu proyecto no es NodeJS, tendrás otras alternativas similares a NigthWatchJS.

(3) Escribir un test de aceptación

Los dos ficheros importantes son nigthwatch.json, que contiene la configuración de nuestro runner, y homePage.test.js, que es el test que vamos a ejecutar contra Selenium.

Dentro de nigthwatch.json debemos colocar:

{
  "src_folders" : ["tests/"],
  "output_folder" : "reports",

  "selenium" : {
    "start_process" : false,
    "log_path" : false,
    "host" : "192.168.33.10",
    "port" : "4444"
  },

  "test_settings" : {
    "default" : {
      "selenium_port"  : "4444",
      "selenium_host"  : "192.168.33.10",
      "silent": true,
      "desiredCapabilities": {
        "browserName": "chrome",
        "javascriptEnabled": true,
        "acceptSslCerts": true
      }
    }

  }
}

Y dentro de homePage.test.js colocamos:

module.exports = {  
  "Demo test Google" : function (browser) {
    browser
      .url("http://www.google.com")
      .waitForElementVisible('body', 1000)
      .setValue('input[type=text]', 'nightwatch')
      .waitForElementVisible('button[name=btnG]', 1000)
      .click('button[name=btnG]')
      .pause(1000)
      .assert.containsText('#main', 'The Night Watch')
      .end();
  }
};

Corremos los test con el comando siguiente:

$ ./node_modules/.bin/nightwatch -c ./nigthwatch.json 

Deberíamos obtener una salida como la siguiente:

Cómo hacer los mejores tests de aceptación y cómo configurar adecuadamente el entorno de testeo es un tema mucho más complejo que queda fuera de este post. Pero tenemos un buen punto de partida al tener ya configurado nuestro servidor Selenium y un test runner adecuado.

Si te ha gustado este post, difunde la palabra. Tampoco dudes en dejar comentarios u observaciones. ¡Gracias! :)

Suscríbete a mi lista de correo

* Campos obligatorios