Tutorial JUnit en Eclipse
JUnit es un framework desarrollado para la realización de tests de unidad. Tiene como principal característica poder definir Tests de forma rápida y sencilla a través de la utilización de etiquetas. También es posible crear clases que sirvan para lanzar conjuntos de tests (TestSuite) y de esta manera automatizar más aún el proceso.
Veamos un ejemplo rápido que espero os ayude a comprender la creación de tests de unidad de una forma eficaz en Eclipse SDK Galileo.
Primero de todo vamos a crear un nuevo proyecto, para ello vamos a File->New->Java Project o pulsamos Shift+Alt+N y seleccionamos Java Project. Da igual el nombre que se le ponga, aseguraros de que teneis la última versión de Java seleccionada, en este caso yo estoy trabajando con JavaSE-1.6.
Una vez creado debereis de crear una carpeta de código por separado para los tests, es una práctica habitual aúnque no es necesario para su funcionamiento. Pero la idea es tener el código del proyecto separado de los tests de unidad.
Como podeis ver en la captura, la idea es crear una estructura similar a esto. En src tendreis el código del proyecto y en tests estarán los tests de unidad. Imaginemos que tenemos una serie de fachadas en el proyecto donde están algunos de los casos de uso que os interesa comprobar su funcionamiento.
Pués para ello creemos un paquete en los tests que tendrá los tests relacionados con este material. Sería interesante crear un paquete más que contenga otros casos de uso, yo crearé un paquete com.miguelpuig.blzarovich.junittutorial.fachada2. Esto lo hago para mostraros más adelante como hacer una Test que lance los tests de las dos fachadas.
Ahora crearemos en fachada1 dos clases Suma y Multiplicacion. Estas dos clases tan simples e inútiles simplemente guardarán dos variables que se podrán sumar y restar. Su código sería tal que así.
package com.miguelpuig.blzarovich.junittutorial.fachada;
public class Suma {
private int a;
private int b;
public Suma(int a, int b) {
this.a = a;
this.b = b;
}
/**
* Suma a + b
* @return a+b
*/
public int suma() {
return a + b;
}
/**
* Resta a - b
* @return a-b
*/
public int resta() {
return a - b;
}
}
Suma tiene dos métodos, para poder hacer la prueba de meter dos tests en una misma clase de junit.
package com.miguelpuig.blzarovich.junittutorial.fachada;
public class Multiplicacion {
private int a;
private int b;
public Multiplicacion(int a, int b) {
this.a = a;
this.b = b;
}
public int multiplicar() {
return a*b;
}
}
Bien, ahora en la fachada2 vamos a hacer lo mismo para la división.
package com.miguelpuig.blzarovich.junittutorial.fachada2;
public class Division {
private int a;
private int b;
public Division(int a, int b) {
this.a = a;
this.b = b;
}
public int divide() {
return a/b;
}
}
Ahora ya tenemos material para poder probar junit. Vereis que es realmente sencillo. Primero vamos a realizar una clase para testear la suma. Para ello botón derecho en el paquete fachada de la carpeta de tests, vais a nuevo y seleccionais JUnit Test Case (en caso de que no aparezca tendreis que pulsar Other y seleccionarlo, la próxima vez aparecerá en el menú directamente). A la clase le podeis llamar SumaTest, aseguraros de seleccionar JUnit4.
Ahora ya podeis crear la clase con el siguiente código.
package fachadatests;
import static org.junit.Assert.assertTrue;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.miguelpuig.blzarovich.junittutorial.fachada.Suma;
public class SumaTest {
public Suma suma;
@Before
public void antesDelTest() {
/**
* El metodo precedido por la etiqueta @Before
* es para indicar a JUnit que debe ejecutarlo
* antes de ejecutar los Tests que figuran en
* esta clase.
*/
this.suma = new Suma(3, 5);
}
@After
public void despuesDelTest() {
/**
* La etiqueta @After es la antítesis de @Before.
* Simplemente este metodo se ejecutara despues de
* ejecutar todos los tests de esta clase.
*/
// en este caso no hago nada, solo esta de ejemplo
}
@Test
public void testSuma() {
/**
* Marcais el metodo con la etiqueta @Test y es
* importante que el nombre del metodo comience
* siempre por test.
*/
int resultado = this.suma.suma();
// con esto verificamos que el resultado es el esperado
assertTrue(resultado == 8);
}
@Test
public void testResta() {
int resultado = this.suma.resta();
assertTrue(resultado == -2);
}
}
Ahora con la multiplicación, sólo que sin before y after. Ya que es una tontería para una clase así, y en la clase anterior sólo se pusieron a modo de demostración. Before y After en realidad están geniales para
cuando realizas tests de unidad al nivel de acceso a datos de una aplicación. Ahí en el Before prepararías
la base de datos para realizar las pruebas y en After desharías los cambios simplemente.
package fachadatests;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
import com.miguelpuig.blzarovich.junittutorial.fachada.Multiplicacion;
public class MultiplicacionTest {
/**
* Lo mismo de antes pero esta vez sin
* before y after.
*/
@Test
public void testMultiplicar() {
Multiplicacion multiplicacion = new Multiplicacion(3, 5);
int resultado = multiplicacion.multiplicar();
assertTrue(resultado == 15);
}
}
Ahora finalmente creamos una clase para la División, será exactamente igual que la anterior pero con la división. Además como la Division está en la fachada2, pués el Junit Test Case lo crearemos en fachada2 de la carpeta de tests.
package fachada2tests;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
import com.miguelpuig.blzarovich.junittutorial.fachada2.Division;
public class DivisionTest {
@Test
public void testDivide() {
Division division = new Division(4, 2);
int resultado = division.divide();
assertTrue(resultado == 2);
}
}
Bien, ya tenemos todos los tests de unidad. Ahora pulsando botón derecho sobre las clases de los tests podreis lanzar los tests pulsando Run as JUnit Test. Yo en principio aún no lo voy a hacer, lo reservo para el final.
Si lo probasteis, podreis observar que igual puede ser un coñazo tener que ejecutar cada Test Case por separado, uno a uno. Esto se puede evitar. Para ello vamos a agrupar los Tests de fachada1 en uno sólo que los ejecutará automáticamente.
Para ello creareis la clase FachadaTests. Que simplemente necesitará de la declaración de la clase, que no tendrá nada dentro. Esta clase estará marcada por dos etiquetas RunWith que le indicará con que clase del framework debe cargar esta clase; y SuiteClasses que tendrá una lista de las clases que son Tests o SuiteClasses. Esto implica que puedes meter SuiteClasses dentro de SuiteClasses y así poder organizar jerárquicamente tus tests.
package fachadatests;
import org.junit.runner.RunWith;
import org.junit.runners.Suite.SuiteClasses;
import org.junit.runners.Suite;
@RunWith(Suite.class)
@SuiteClasses({SumaTest.class, MultiplicacionTest.class})
public class FachadaTests {}
Así de simple queda la clase. Ahora realizaremos una clase similar a esta en el raiz de la carpeta tests. Para ejecutar todos los tests conjuntamente, esta se llamará AllTests. Os la meterá en el default package, tranquilos.
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
import fachada2tests.DivisionTest;
import fachadatests.FachadaTests;
@RunWith(Suite.class)
@SuiteClasses({FachadaTests.class, DivisionTest.class})
public class AllTests {}
Como veis en el SuiteClasses podeis mezclar tests simples y TestSuite 
. Ya teneis vuestros tests preparados para ejecutar por lote. Vamos ahora a pulsar botón derecho en AllTests y seleccionar Run as JUnit Test. Automáticamente el Eclipse lanzará todos los tests que teneis programados y os aparecerá un resultado parecido a esto.
Como veis todos los tests salieron con resultados satisfactorios. Ahora os recomiendo jugar y probar vosotros mismos con todo esto, meter en los assertTrue resultados no esperados, para que veais que pasa cuando falla, añadir más clases, hacer pruebas más complejas o probar toda la colección de asserts que podeis utilizar (assertEquals, assertNull, assertNotNull, etc).
Código fuente del proyecto utilizado como ejemplo
Links relacionados:
