El orden de las pruebas en JUnit

1. Información general

De forma predeterminada, JUnit ejecuta pruebas utilizando un orden determinista, pero impredecible ( MethodSorters.DEFAULT ).

En la mayoría de los casos, ese comportamiento está perfectamente bien y es aceptable; pero hay casos en los que necesitamos hacer cumplir un pedido específico.

2. Orden de prueba en JUnit 5

En JUnit 5, podemos usar @TestMethodOrder para controlar el orden de ejecución de las pruebas .

Podemos usar nuestro propio MethodOrderer , como veremos más adelante, o podemos seleccionar uno de los tres ordenadores integrados:

  1. @ Anotación de pedido
  2. Orden alfanumérico
  3. Orden aleatorio

2.1. Uso de la anotación @Order

Podemos usar la anotación @Order para hacer que las pruebas se ejecuten en un orden específico.

En el siguiente ejemplo, los métodos se ejecutarán en este orden: firstTest () , luego secondTest () y, finalmente, thirdTest () :

@TestMethodOrder(OrderAnnotation.class) public class OrderAnnotationUnitTest { private static StringBuilder output = new StringBuilder(""); @Test @Order(1) public void firstTest() { output.append("a"); } @Test @Order(2) public void secondTest() { output.append("b"); } @Test @Order(3) public void thirdTest() { output.append("c"); } @AfterAll public static void assertOutput() { assertEquals(output.toString(), "abc"); } }

2.2. Uso de orden alfanumérico

También podemos ejecutar pruebas basadas en sus nombres en orden alfanumérico:

@TestMethodOrder(Alphanumeric.class) public class AlphanumericOrderUnitTest { private static StringBuilder output = new StringBuilder(""); @Test public void myATest() { output.append("A"); } @Test public void myBTest() { output.append("B"); } @Test public void myaTest() { output.append("a"); } @AfterAll public static void assertOutput() { assertEquals(output.toString(), "ABa"); } }

Tenga en cuenta que el orden alfanumérico distingue entre mayúsculas y minúsculas, por lo que los caracteres en mayúsculas van primero y luego en minúsculas.

Las pruebas se ejecutarán en este orden: myATest () , myBTest () y finalmente myaTest () .

2.3. Usando un pedido personalizado

Finalmente, podemos usar nuestro propio orden personalizado implementando la interfaz MethodOrderer .

En nuestro CustomOrder , ordenaremos las pruebas según sus nombres en un orden alfanumérico que no distingue entre mayúsculas y minúsculas:

public class CustomOrder implements MethodOrderer { @Override public void orderMethods(MethodOrdererContext context) { context.getMethodDescriptors().sort( (MethodDescriptor m1, MethodDescriptor m2)-> m1.getMethod().getName().compareToIgnoreCase(m2.getMethod().getName())); } }

Luego, usaremos CustomOrder para ejecutar las mismas pruebas de nuestro ejemplo anterior en este orden: myATest () , myaTest () y, finalmente, myBTest () :

@TestMethodOrder(CustomOrder.class) public class CustomOrderUnitTest { // ... @AfterAll public static void assertOutput() { assertEquals(output.toString(), "AaB"); } }

3. Orden de prueba en JUnit 4

Si todavía está usando JUnit 4, las API para solicitar pruebas son ligeramente diferentes.

Repasemos las opciones para lograr esto en versiones anteriores también.

3.1. Usando MethodSorters.DEFAULT

Esta estrategia predeterminada compara los métodos de prueba utilizando sus códigos hash. En caso de colisión hash, se utiliza el orden lexicográfico:

@FixMethodOrder(MethodSorters.DEFAULT) public class DefaultOrderOfExecutionTest { private static StringBuilder output = new StringBuilder(""); @Test public void secondTest() { output.append("b"); } @Test public void thirdTest() { output.append("c"); } @Test public void firstTest() { output.append("a"); } @AfterClass public static void assertOutput() { assertEquals(output.toString(), "cab"); } }

Cuando ejecutemos las pruebas en la clase anterior, veremos que todas pasan, incluido assertOutput () .

3.2. Usando MethodSorters.JVM

Otra estrategia de pedido es MethodSorters.JVM : esta estrategia utiliza el pedido natural de JVM, que puede ser diferente para cada ejecución:

@FixMethodOrder(MethodSorters.JVM) public class JVMOrderOfExecutionTest { // same as above }

Cada vez que ejecutamos las pruebas en esta clase, obtenemos un resultado diferente.

3.3. Usando MethodSorters.NAME_ASCENDING

Finalmente, esta estrategia se puede utilizar para ejecutar pruebas en su orden lexicográfico:

@FixMethodOrder(MethodSorters.NAME_ASCENDING) public class NameAscendingOrderOfExecutionTest { // same as above @AfterClass public static void assertOutput() { assertEquals(output.toString(), "abc"); } }

Del mismo modo, cuando ejecutamos las pruebas en esta clase, vemos que todas pasan, incluido assertOutput () , que confirma el orden de ejecución que establecemos con la anotación.

4. Conclusión

En este tutorial rápido, analizamos las formas de establecer el orden de ejecución disponible en JUnit.

Y, como siempre, los ejemplos utilizados en este artículo se pueden encontrar en GitHub.