En este articulo me gustaría mostrar un ejemplo de cómo crear y usar una regla con JUnit para hacer las pruebas de cualquier aplicación de una forma mucho más fácil.

En este ejemplo no solo se probará el código con el que interactúa directamente el usuario, sino también el código que es el encargado de realizar la conexión con la base de datos.

BaseTest también limpia la DB en el método @After.

Nota importante: Este artículo es acerca de cómo cambiar las pruebas con JUnit, que no están estructuradas correctamente.

Enfoque

Con el fin de lograr un buen testing del código, se realizo tres cosas: La primera fue para cambiar la herencia de la clase de prueba. Se  dejó de heredar de BaseTest. En su lugar, hereda de AbstractJUnit4SpringContextTests. Ahora se puede crear un propio contexto por prueba y cargar todo.

Ahora, es necesario hacer uso de dos reglas, @ClassRule y @Rule @ClassRule serán las responsables de la conexióna la DB. @Rule hará la limpieza de la DB antes y después de cada prueba.

Pero primero, ¿cuáles son las Reglas Con JUnit?

Estas ofrecen la posibilidad de interceptar el método de prueba, similar al concepto de AOP. @Rule Nos permite interceptar un método antes y después de la ejecución real del método. La clase @ClassRule ejecuta la clase de prueba. Una muy conocido @Rule de JUnit es TemporaryFolder.

(Similar a @Before, @After and @BeforeClass).

Creando @Rule Para La Depuración

La parte fácil es crear reglas con JUnit que limpien antes y después de un método de prueba con la DB. Es necesario implementar TestRule, que tiene un método: Statement apply(Statement base, Description descripción); puedes hacer varias cosillas con él 😉

Aquí está el código completo del ejemplo:

public class DbCleanupRule implements TestRule {
 private final DbConnectionManager connection;

 public MongoCleanupRule(DbConnectionManager connection) {
  this.connection = connection;
 }

 @Override
 public Statement apply(Statement base, Description description) {
  return new MongoCleanupStatement(base, connection);
 }

 private static final class DbCleanupStatement extends Statement {
  private final Statement base;
  private final DbConnectionManager connection;
  
  private MongoCleanupStatement(Statement base, DbConnectionManager connection) {
   this.base = base;
   this.connection = connection;
  }

  @Override
  public void evaluate() throws Throwable {
   try {
    cleanDb();
    base.evaluate();
   } finally {
    cleanDb();
   }
  }
  
  private void cleanDb() {
   connection.doTheCleanup();
  }
 }
}

Creando @ClassRule Para La Conexión Con La Base De Datos

ClassRule funciona en realidad como TestRule. El desafío en la creación de esta regla, es el usar el contexto de Spring para conseguir la correcta conexión con la base de datos.

Aquí está el código:

public class DbConnectionRule extends ExternalResource {
 private DbConnectionManager connection;

 public DbConnectionRule() {
 }
 
 @Override
 protected void before() throws Throwable {
  ClassPathXmlApplicationContext ctx = null;
  try {
   ctx = new ClassPathXmlApplicationContext("/META-INF/my-db-connection-TEST-ctx.xml");
   mongoDb = (DbConnectionManager) ctx.getBean("myDbConnection");
  } finally {
      if (ctx != null) {
          ctx.close();
      }
  }
 }
 
 @Override
 protected void after() {
 }
 
 public DbConnectionManager getDbConnecttion() {
  return connection;
 }
}

Usándolo

La última parte, es la forma en que usamos las reglas. Una @Rule debe ser de acceso público. Una @ClassRule debe ser de acceso publico y estático (public static).

El siguiente seria el código a usar:

@ContextConfiguration(locations = { "/META-INF/one-dao-TEST-ctx.xml", "/META-INF/two-TEST-ctx.xml" })
public class ExampleDaoTest extends AbstractJUnit4SpringContextTests {

 @ClassRule
 public static DbCleanupRule  connectionRule = new DbCleanupRule ();
 
 @Rule
 public DbCleanupRule dbCleanupRule = new DbCleanupRule(connectionRule.getDbConnecttion()); 

 @Autowired
 private ExampleDao classToTest;

 @Test
 public void foo() {
 }
}

 
Eso es todo. Espero te haya ayudado este pequeño consejo.