Admin: /* La regla de JUnit */

2012-02-24T12:34:04Z

‎La regla de JUnit

Admin: /* La regla de JUnit */

2012-02-23T20:50:14Z

‎La regla de JUnit

Admin: Página creada con 'Es muy común tener que integrar JUnit para ejecutar tests contra una base de datos. Vamos a ver algunas facilidades que nos provee JUnit y Spring Framework para hac…'

2012-02-23T20:16:04Z

Página creada con 'Es muy común tener que integrar JUnit para ejecutar tests contra una base de datos. Vamos a ver algunas facilidades que nos provee JUnit y Spring Framework para hac…'

Página nueva

Es muy común tener que integrar [[JUnit]] para ejecutar tests contra una base de datos. Vamos a ver algunas facilidades que nos provee [[JUnit]] y [[Spring Framework]] para hacer más facil la ejecución de tests contra datos siempre limpios.

== embedded-database de Spring ==
[[Spring Framework]] contiene una utilidad para levantar bases de datos en memoria al momento que se inicializa el factory. De esta forma, podemos inicializar una base y a la vez decirle que ejecute varios scripts, para dejarla preparada y lista para usar.

Un archivo de configuración de ejemplo:
<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd">

<jdbc:embedded-database id="dataSource" type="HSQL" />

<jdbc:initialize-database data-source="dataSource" ignore-failures="NONE">
<jdbc:script location="classpath:tablas.sql" />
<jdbc:script location="classpath:datos.sql "/>
</jdbc:initialize-database>

</beans>
</code>

Esta configuración crea un bean llamada "dataSource" que es un DataSource común, listo para inyectar en nuestra aplicación (y reemplazar así un DataSource real). Este DataSource apunta a una base en memoria HSQLDB, y ejecutarán 2 scripts al momento de inicialización: tablas.sql y datos.sql

== Limpieza del contexto de Spring en los tests ==
Es posible que algún método de test "ensucie" (cambie) el valor de algún bean del factory, lo cual ocasione problemas en tests posteriores. Podemos usar la anotación @DirtiesContext para indicarle a Spring que vuelva a crear un nuevo factory luego de la ejecución del método anotado con esta anotación.

Por ejemplo:

<code java5>
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {
"classpath:datasource-test.xml",
"classpath:applicationContext.xml"
})
public class MiTest {

@Test
public void fooTest() { ... }

@Test
@DirtiesContext
public void barTest() { ... }
}
</code>

En este ejemplo, al terminar la ejecución del método barTest() se volverá a crear el factory de Spring (y por lo tanto, se creará una nueva base en memoria). De esta manera el resto de los métodos contarán con un entorno limpio.

== Limpieza de la base de datos con Rules de JUnit ==

En la mayoría de las ocasiones, los métodos @Test no ensucian el contexto de beans de Spring, sino que ensucian los datos de la base de datos (realizando inserts, updates, deletes sobre los mismos). Los métodos posteriores de tests podrían verse afectados por no contar con los datos tal cual se los esperaba.

Una solución es anotar a estos tests que ensucian la base de datos con @DirtiesContext. Esto forzará la creación de un nuevo contexto de Spring, y se recreará la correspondiente base de datos en memoria. Sin embargo, esta solución es relativamente costosa por la continua destrucción/construcción del factory de Spring.

Una solución alternativa será usar un @DirtiesDatabase que sólo recree la base de datos en memoria... sin embargo, Spring no tiene esta utilidad. Por suerte, es muy simple agregarla.

=== @DirtiesDatabase ===
Crearemos una anotación de método que nos permita indicar que un método de @Test ensucia la base de datos, y luego usaremos una Regla de [[JUnit]] para leer esta anotación y hacer la limpiaza necesaria.

==== La anotación ====
La anotación es común:
<code java5>
@Retention(RetentionPolicy.RUNTIME)
public @interface DirtiesDatabase { }
</code>

==== La regla de JUnit ====
Primera vamos a crear una interfaz para una clase que se encargue de reconstruir la base de datos:
<code java5>
public interface DatabaseRebuilder {
void rebuildDatabase();
}
</code>

Luego, crearemos una regla de [[JUnit]] que buscará esta anotación, y si la encuentra, limpiará la base de datos:
<code java5>
public class DirtiesDatabaseRule implements TestRule {

private DatabaseRebuilder rebuilder;

public DirtiesDatabaseRule(DatabaseRebuilder rebuilder) {
this.rebuilder = rebuilder;
}

@Override
public Statement apply(final Statement base, final Description description) {
return new Statement() {
@Override
public void evaluate() throws Throwable {
try {
base.evaluate();
} finally {
DirtiesDatabase dirtiesDatabase = description.getAnnotation(DirtiesDatabase.class);
if (dirtiesDatabase != null) {
rebuilder.rebuildDatabase();
}
}
}
};
}
}
</code>

==== Usando @DirtiesDatabase ====
Listo! Nos queda agregar la regla a la clase de test, y la anotación correspondiente.

<code java5>
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {
"classpath:datasource-test.xml",
"classpath:applicationContext.xml"
})
public class MiTest {

@Rule
public DirtiesDatabaseRule dirtiesDatabaseRule = new DirtiesDatabaseRule(new DatabaseRebuilderImpl());

@Test
public void fooTest() { ... }

@Test
@DirtiesDatabase
public void barTest() { ... }
}
</code>

@@ Línea 78: / Línea 78: @@
 ==== La regla de JUnit ====
-Luego, crearemos una regla de [[JUnit]] que buscará esta anotación, y si la encuentra, limpiará la base de datos:
+Luego, crearemos una regla de [[JUnit]] que buscará esta anotación, y si la encuentra, reconstruye la base de datos. Esta regla usa una instancia de DatabaseRebuilder para hacer la reconstrucción de la base de datos:
 <code java5>
 public class DirtiesDatabaseRule implements TestRule {

@@ Línea 67: / Línea 67: @@
 </code>
-==== La regla de JUnit ====
+==== DatabaseRebuilder para reconstruir la base de datos ====
-Primera vamos a crear una interfaz para una clase que se encargue de reconstruir la base de datos:
+Primero vamos a crear una interfaz para una clase que se encargue de reconstruir la base de datos:
 <code java5>
 public interface DatabaseRebuilder {
@@ Línea 75: / Línea 75: @@
 </code>
 Luego, crearemos una regla de [[JUnit]] que buscará esta anotación, y si la encuentra, limpiará la base de datos:
 <code java5>

JUnit con bases de datos - Historial de revisiones

Admin: /* La regla de JUnit */

Admin: /* La regla de JUnit */

Admin: Página creada con 'Es muy común tener que integrar JUnit para ejecutar tests contra una base de datos. Vamos a ver algunas facilidades que nos provee JUnit y Spring Framework para hac…'