Anotaciones BeforeClass y AfterClass

15 de febrero de 2016 • Duración: 5:32

En este episodio nos centramos en dos anotaciones más: BeforeClass y AfterClass. La primera sirve para ejecutar código antes de cualquier prueba en una clase. AfterClass lo mismo pero después. Ambas se suelen usar típicamente para preparar recursos compartidos que son costosos de inicializar y que, por lo tanto, preferiríamos instanciar una única vez antes de lanzar toda la suite de tests, pero que queremos reutilizar a lo largo de todos los casos de prueba que se ejecutan dentro de una clase, reservando el AfterClass para poder limpiar ese recurso si hace falta. En este vídeo lo vemos dentro de un flujo de ejecución y lo comparamos con Before y After.

BeforeClass y AfterClass son dos anotaciones que se comportan como Before y como After, pero que tienen la particularidad de que sólo se van a ejecutar una vez. BeforeClass se va a ejecutar antes de cualquier prueba unitaria que se ejecute dentro de la clase y AfterClass se va a ejecutar después de cualquier otra prueba que se haya ejecutado.

Son anotaciones que, por lo tanto, nos van a permitir inicializar toda una clase de test, y limpiar toda una clase de test. A menudo las podemos usar para instanciar de forma global para todos los casos de un test un recurso costoso de inicializar, para no ralentizar demasiado toda una suite de test. Podría ser el caso de una conexión que hay que establecer para completar un test de integración. Tal vez levantar un navegador o todo un cliente de bases de datos en el @Before sea muy costoso. Podríamos usar un @BeforeClass para mantener el recurso cargado al inicio del test, y limpiarlo en el @AfterClass una vez que ya no quedan tests que vayan a hacer uso de él.

Una cosa que tienes que tener en cuenta con este método es que es estático, así que si tienes que manipular algún atributo que quieras que sea accesible desde los propios tests, tendrás que tener esto en cuenta y declarar los atributos también como estáticos.

Dentro del ciclo de vida de ejecución, en su forma más simple un test anotado como BeforeClass y AfterClass tendría la siguiente forma:

public class LifecycleTest {
    @BeforeClass
    public static void setUpClass() {
        DatabaseManager.getInstance().connect();
    }

    @AfterClass
    public static void tearDownClass() {
        DatabaseManager.getInstance().stop();
    }

    @Test
    public void testCursor() {
        Cursor db = DatabaseManager.getInstance().cursor();
        assertNotNull(db);
    }
}

En un caso más avanzado, vamos a imprimir una salida en cada uno de los métodos del ciclo de vida para ver su ejecución.

public class LifecycleTest {
    @Before
    public void setUp() {
        System.out.println("before");
    }

    @After
    public void tearDown() {
        System.out.println("after");
    }

    @Test
    public void testUno() {
        System.out.println("test - uno");
    }

    @Test
    public void testDos() {
        System.out.println("test - dos");
    }

    @BeforeClass
    public static void setUpClass() {
        System.out.println("beforeClass");
    }

    @AfterClass
    public static void tearDownClass() {
        System.out.println("afterClass");
    }
}

Al ejecutar esto, obtenemos lo siguiente:

beforeClass
before
test - uno
after
before
test - dos
after
afterClass

En este caso, vemos que la primera y la última línea se corresponde, respectivamente, con el BeforeClass y con el AfterClass. Se ejecutan antes y después y envuelven todo lo que hagamos entre medias dentro de la clase. Dentro, tenemos los dos grupos de tres líneas before-uno-after y before-dos-after, como ya vimos en la lección sobre Before y After.