Pruebas Software con Junit 4 y Eclipse

Pruebas Software con Junit 4 y Eclipse

0. Índice de contenidos.

• 1. Introducción.
• 2. Entorno
• 3. ¿Por qué usar Test?
• 4. Características de JUnit 4
• 4.1. Métodos
• 4.2. Anotaciones
• 4.3. Funciones de aceptación/rechazo
• 4.4. Ejemplo
• 5. Junit en Eclipse

1. Introducción

JUnit se trata de un Framework Open Source para la automatización de las pruebas (tanto unitarias, como de integración) en los proyectos Software. El framework provee al usuario de herramientas, clases y métodos que le facilitan la tarea de realizar pruebas en su sistema y así asegurar su consistencia y funcionalidad.

En este tutorial os vamos a enseñar el funcionamiento de la última versión de Junit, Junit 4, y su integración con el entorno de desarrollo Eclipse. Ámbas herramientas son open Source y pueden ser descargadas gratuitamente en los siguientes enlaces:

• JUnit4: (Web Oficial | Descarga)
• Eclipse: ( Web Oficial | Descarga)

2. Entorno

Las características del equipo y recursos utilizados para las pruebas y la elaboración de este tutorial son las siguientes:

• Equipo: Portátil «ASUS Notebook G1 Series» (Core 2 Duo T7500 2.20GHz, 2GB RAM, 100 GB HD).
• Sistema operativo: Windows Vista Ultimate.
• Eclipse Ganymede 3.4.1
• Junit 4.5

3. ¿Por qué usar Test?

Os vamos a explicar de manera sencilla que son conceptualmente los test y por qué son necesarios en nuestro proyecto Software.

Pongamos que nos encontramos en una situación típica de cualquier sistema en desarrollo con varios desarrolladores trabajando en paralelo, cada uno en un módulo independiente pero todos éstos suelen estar relacionados.

En primer lugar tenemos que decir que existen principalmente 2 tipos de pruebas con las que vamos a trabajar, estas son:

• Pruebas unitarias: Consisten en probar la correcta funcionalidad del módulo en cuestión como si actuara independiente de los demás.
• Pruebas de integración: Como su nombre indica, se prueba la correcta integración de cada módulo (ya probado con pruebas unitarias) con los demás

Supongamos que el sistema está implementado, probado y ya en funcionamiento, pero se desea añadir una nueva funcionalidad al módulo 4. Tras el desarrollo de éste, ¿estamos seguros de que los demás módulos siguen funcionando correctamente y no se ha alterado su funcionalidad?.
La manera más rudimentaria y primitiva es probar a mano todos los módulos relacionados…¿No sería más facil automatizar este proceso?. Automatizando la tarea de realizar las pruebas conseguimos, además de ganar tiempo cada vez que tengamos que hacer las pruebas,
asegurarnos que se realizan todas las pruebas necesarias.

Mediante pruebas de integración no solo se nos permite probar la interacción de un módulo con otro dentro del mismo sistema, sino que podemos probar las conexiones con otros sistemas externos como por ejemplo un gestor de Base de datos.

Por otro lado, se ha demostrado que una forma muy eficaz, limpia y profesional de trabajar es realizar una programación basada en pruebas. Esto consiste en invertir el proceso natural de desarrollo, cogiendo los requisitos, realizando una batería de pruebas a partir de éstos
para finalmente desarrollar el sistema que los cumpla.

En resumen, un proyecto Software no puede considerarse como tal sin una buena batería de pruebas que comprueben su correcto funcionamiento frente a cambios

4. Características de JUnit 4

En primer lugar e importante es que el nombre de la clase de Test debe tener la siguiente estructura: «test»

4.1. Métodos

A grandes rasgos, una clase de Test realizada para ser tratada por JUnit 4 tiene una estructura con 4 tipos de métodos:

• Método setUp: Asignamos valores iniciales a variables antes de la ejecución de cada test. Si solo queremos que se inicialicen al principio una vez, el método se debe llamar «setUpClass»
• Método tearDown: Es llamado después de cada test y puede servir para liberar recursos o similar. Igual que antes, si queremos que solo se llame al final de la ejecución de todos los test, se debe llamar «tearDownClass»
• Métodos Test: Contienen las pruebas concretas que vamos a realizar.
• Métodos auxiliares.

4.2. Anotaciones

En versiones anteriores de Junit no existían caracteres especiales, que llamamos anotaciones, y que se han incluído en su versión 4 para intentar simplificar más la labor del programador. Se trata de palabras clave que se colocan delante de los definidos antes y que indican a las librerías JUnit instrucciones concretas.

A continuación pasamos a ver las más relevantes:

• @RunWith: Se le asigna una clase a la que JUnit invocará en lugar del ejecutor por defecto de JUnit
• @Before: Indicamos que el siguiente método se debe ejecutar antes de cada test (precede al método setUp). Si tiene que preceder al método setUpClass, la notación será «@BeforeClass»
• @After: Indicamos que el siguiente método se debe ejecutar después de cada test (precede al método tearDown). Si tiene que preceder al método tearDownClass, la notación será «@AfterClass»
• @Test: Indicamos a Junit que se trata de un método de Test. En versiones anteriores de JUnit los métodos tenían que tener un nombre con la siguiente estructura: «test». Con esta notación colocada delante de los métodos podemos elegir el nombre libremente.

4.3. Funciones de aceptación/rechazo

Una vez hemos creado las condiciones para probar que una funcionalidad concreta funciona es necesario que un validador nos diga si estamos obteniendo el resultado esperado o no. Para esta labor se definen una lista de funciones (incluidas en la clase Assert) que se pueden ver detalladas en el javadoc de JUnit: Javadoc

Os pasamos a detallar las más comunes para así ahorraros trabajo:

• assertArrayEquals: Recibe como parámetro 2 arrays y comprueba si son iguales. Devuelve assertionError si no se produce el resultado esperado
• assertEquals: Realiza la comprobación entre 2 valores de tipo numérico. Devuelve assertionError si no se produce el resultado esperado
• assertTrue: Comprueba si una condición se cumple. Devuelve assertionError si no se produce el resultado esperado
• fail: devuelve una alerta informando del fallo en el test

4.4. Ejemplo

package com.autentia.training.tutorialJUnit;

import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;

public class pruebaTest {

	@BeforeClass
	public static void setUpClass() throws Exception {
	//Inicialización general de variables, escritura del log...
	}
	
	@AfterClass
	public static void tearDownClass() throws Exception {
	//Liberación de recursos, escritura en el log...
	}
	
	@Before
    public void setUp() {
    //Inicialización de variables antes de cada Test
    }
	
	@After
    public void tearDown() {
    //Tareas a realizar después de cada test
    }
	
	@Test
    public void comprobarAccion() {
    //creamos el entorno necesario para la prueba
	//Usamos alguna de las funciones arriba descritas 
	//para realizar la comprobación
    }
	
    public void funcionAuxiliar() {
    //tareas auxiliares
    }
	
}

5. JUnit en Eclipse

La versión actual de Eclipse (Ganymede, 3.4) ya incluye la integración de éste con las librerias JUnit por lo que es sencillísimo ejecutar una clase de Test. Unicamente tenemos que abrirnos
la vista de explorador de proyectos, aquí hacer clic con el botón derecho en la clase Test en concreto, en el menú que aparece elegir «Run as» -> «JUnit Test»

En la consola nos aparecerá el resultado de la ejecución

Espero haberos sido de utilidad. Le debo un agradecimiento a nuestro compañero Raúl que me dió todas las bases para hacer este tutorial

Un saludo.

Rubén Gómez

mailto:rgomez@autentia.com