Pruebas unitarias con jwebunit

0
17205

Pruebas unitarias con
jwebunit

Pruebas
unitarias con jwebunit 1

Introducción. 1

Instalación
de jwebunit 1

Ejemplo en
Eclipse sobre una aplicación JSF. 2

Creación de
un test unitario web con jwebunit 8

Resumen de
funciones. 13

Puntos
débiles. 14

La nueva
versión JWebUnit 2.0. 14

Conclusiones. 14

 

Introducción

En el tutorial anterior sobre pruebas unitarias web, vimos
varios frameworks (marcos de trabajo) de pruebas unitarias de tipo Open Source
para el mundo Java. En este tutorial nos vamos a aproximar al framework
jWebUnit, que es un proyecto muy interesante para realizar rápidamente una
buena batería de pruebas unitarias para nuestra aplicación web.

 

Vamos a ver cómo podemos realizar pruebas unitarias con
jwebunits. Este framework es una extensión de los frameworks junit y htmlunit,
especialmente indicado para probar la interfaz de la aplicación. Con este
framework, nuestras pruebas podrán interactuar con la aplicación web, simulando
las diferentes acciones del usuario, y revisando la interfaz que genera la
aplicación en cada momento.

 

Instalación de jwebunit

Nos vamos a la página web del proyecto http://jwebunit.sourceforge.net y
descargamos el zip que contiene el paquete jwebunits. Yo me he descargado la
versión jwebunit-1.3.zip

 

 

Como en todos los proyectos de Sourceforge.net, en la
sección de descargas encontraremos los ficheros. Una vez descargado el paquete
lo descomprimimos y veremos lo siguiente:

 

  • Dos archivos jar, el que contiene jwebunit (jwebunit-core-1.3.jar)
    y el que contiene el plugin de htmlunit (jwebunit-htmlunit-plugin-1.3.jar)
  • Una carpeta lib con todos los jar de los que depende.
  • Los jar con los fuentes en la carpeta src
  • El javadoc de jwebunit en la carpeta javadoc
  • Los ficheros con las licencias

 

Normalmente jwebunit lo usaremos desde una herramienta de
compilación automática, como puede ser ANT, Maven o similares, o desde un
entorno de desarrollo, como puede ser Eclipse. En el caso de usar Maven, que es
el entono de compilación usado por los desarrolladores de jwebunit, en la
página del proyecto nos dan las sencillas instrucciones para incluir jwebunit
en nuestros proyectos.

 

Para añadirlo manualmente a nuestros proyectos, incluiremos
los jar en el classpath de nuestra herramienta de compilación o de nuestro IDE
y crearemos los test unitarios de un modo similar a como se hace con junit.

 

Ejemplo en Eclipse
sobre una aplicación JSF

 

Creamos una carpeta para las pruebas unitarias, por ejemplo
“PruebasUnitarias” y dentro de ella creamos un paquete, en nuestro caso
com.autentia.ejemplojsf.pruebasunitarias:

 

 

Ahora añadimos una prueba (test case, en terminología junit)

 

Para que podamos ejecutar los test hay que añadir al Java
Build Path (el classpath del proyecto) las bibliotecas jar de jwebunit.

 

 

Por defecto nuestro proyecto no dispone del entorno junit ni
de jwebunit

 

Ahora añadimos el entorno junit. Para ello pulsamos en “Add
Libraries”

 

 

Seleccionamos “JUnit” y pulsamos “Next”

 

 

Seleccionamos la versión ofrecida por defecto y pulsamos
“Finish”.

 

 

Ahora añadimos las bibliotecas de jWebUnit. Para ello
copiamos todos los ficheros de jwebunit a una carpeta del proyecto. Si queremos
borramos los que no nos hagan falta.

 

 

Volvemos a abrir el diálogo de “Java Build Path” como hemos
hecho antes y pulsamos “Add Jars…”

 

 

Elegimos los jar de jWebUnit y pulsamos OK.

 

 

Ahora nos faltan las dependencias de jwebunit, que son
aquellas que necesitemos de la carpeta lib del jwebunit, por ejemplo
regexp-1.3.jar

 

 

 

Creación de un test
unitario web con jwebunit

 

Vamos a probar una aplicación de prueba JSF que realiza lo
siguiente:

 

  • Al abrir la página de inicio.faces se muestra la página de
    inicio de la aplicación

 

 

  • Tras introducir el usuario y la contraseña, se pulsa en el
    botón “Iniciar”, si la contraseña es correcta, nos lleva a la página de
    inicio principal. Si es incorrecta nos lleva a una página de error. Hemos
    puesto de  contraseña “sesamo”. Si la contraseña no es correcta, nos
    muestra de nuevo el formulario y en el texto de usuario escribe
    “Reintentar”

 

El código de la página de inicio es:

 

Inicio.jsp

 

El código de la página principal es:

 

Principal.jsp

 

 Como vemos es un código muy simple, y nos basta para ver el
jwebunit en funcionamiento.

 

Ahora creamos con el asistente de Eclipse una prueba
unitaria web

 

 

 

El asistente del Eclipse nos genera automáticamente el
siguiente código:

 

EjemplojcrissfTestCase.java

 

Ahora ya sólo nos queda ir añadiendo las funciones de
pruebas unitarias.

 

EjemplocrisjsfTestCase.java

 

Ahora ejecutamos las pruebas unitarias. Para ello:

  1. Arrancamos el servidor donde vamos a probar la aplicación.
    Si no sabes cómo, consulta mi tutorial sobre JSF en la página web de www.adictosaltrabajo.com
  2. Prueba las páginas inicio.jsp y principal en el servidor,
    con el “Run as\Run on server”, para no encontrarnos errores “extraños”
    luego.
  3. Pásate a la perspectiva “Test” en Eclipse
  4. Pulsa con el botón derecho sobre el fichero
    EjemplocrisjsfTestCase.java y selecciona “Run as\Junit test”

 

 

Si todo va bien, obtendrás una pantalla como la que muestro.
La raya verde indica que las dos pruebas unitarias ejecutadas han sido
satisfactorias.

 

Resumen de funciones

Los objetos principales que utilizaremos para hacer las
pruebas unitarias serán:

  • TestContext. Establece un contexto para realizar las
    pruebas (locale, url base, cookies, autentificación).
  • WebTester. Es el objeto que realizará las pruebas.
    Algunos de los métodos que puede utilizar son:
    • Métodos assert, del tipo assertButtonPresent(“idBoton”). Algunos
      ejemplos (con el assert delante) serían las familias button* (present,
      notpresent, etc.), check*, element*, cookie*, form*, frame*, key*, link*,
      radio*, selectoption*, selectedoption*, submitButton*, table*, text*,
      title^*, windows*, donde el * indica que hay varios métodos disponibles,
      adaptados a cada tipo de elemento.
    • Métodos clic* para simular el pulsado sobre un elemento
      de la ventana
    • dumpHtml, que muestra en la salida estándar el código
      html que se está viendo en cada momento, muy útil para depurar nuestros
      test.
    • Métodos get, como getDialog, que permiten obtener varios elementos
      de la página o del contexto
    • Métodos goto, como gotoFrame, gotoWindow, gotoRootWindow,
      gotoPage, que nos permitirán navegar por la página.
    • Métodos submit, para que los formularios se envíen
    • Métodos set, para fijar el valor de los elementos de la
      página.

Puntos débiles

Los puntos débiles de Jwebunit vienen de los que muestren
las bibliotecas de bajo nivel que utilicen. Por ejemplo, si usamos htmlunit, en
su versión 1.9 tenemos  por ejemplo los siguientes problemas:

  • Si la página tiene un código javascript bastante complejo,
    nos puede dar problemas. Esto por ejemplo sucede si usamos determinados
    componentes JSF, que para almacenar su estado interno se apoyan
    fuertemente en código javascript.
  • Upload de ficheros. Es un tema que no dispone de
    documentación.
  • Alerts de javascript. Al no disponer de títulos o
    elementos html, no se pueden gestionar correctamente.
  • La navegación por páginas con frames, que requiere un
    código algo complejo.

 

La nueva versión JWebUnit 2.0

Se está preparando (Noviembre 2006) la nueva versión 2.0 del
framework, que ya soporta cuatro plugins: htmlunit, httpunit, Selenium y
Jwebfit. Parece que este entorno se configura como el más prometedor para
pruebas web automáticas desde java.

Estaremos atentos a la evolución de este proyecto, pues de
su desarrollo dependerá la potencia de las pruebas unitarias web de nueva
generación.

Conclusiones

Con Jwebunti podremos incluir de manera sencilla pruebas
unitarias web en nuestros proyectos. Es un buen marco de trabajo (framework)
tanto para realizar pruebas funcionales como para ver el comportamiento de
componentes concretos de nuestra aplicación.

Si nuestro entorno de pruebas lo completamos con una
plataforma de compilación automática, por ejemplo un sistema de versionado,
compilación nocturna y de despliegue automático en un servidor web de pruebas,
podremos automatizar todo el proceso de compilación, empaquetado y pruebas de
la aplicación. Pero esto lo dejamos para otro tutorial…

Dejar respuesta

Please enter your comment!
Please enter your name here