java junit - Diferencia entre @Before, @BeforeClass, @BeforeEach y @BeforeAll




example spring (4)

Las diferencias entre cada anotación son:

+-------------------------------------------------------------------------------------------------------+
¦                                       Feature                            ¦   Junit 4    ¦   Junit 5   ¦
¦--------------------------------------------------------------------------+--------------+-------------¦
¦ Execute before all test methods of the class are executed.               ¦ @BeforeClass ¦ @BeforeAll  ¦
¦ Used with static method.                                                 ¦              ¦             ¦
¦ For example, This method could contain some initialization code          ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Execute after all test methods in the current class.                     ¦ @AfterClass  ¦ @AfterAll   ¦
¦ Used with static method.                                                 ¦              ¦             ¦
¦ For example, This method could contain some cleanup code.                ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Execute before each test method.                                         ¦ @Before      ¦ @BeforeEach ¦
¦ Used with non-static method.                                             ¦              ¦             ¦
¦ For example, to reinitialize some class attributes used by the methods.  ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Execute after each test method.                                          ¦ @After       ¦ @AfterEach  ¦
¦ Used with non-static method.                                             ¦              ¦             ¦
¦ For example, to roll back database modifications.                        ¦              ¦             ¦
+-------------------------------------------------------------------------------------------------------+

La mayoría de las anotaciones en ambas versiones son iguales, pero pocas diferencias.

Reference

Orden de Ejecución.

Cuadro de guiones -> anotación opcional.

¿Cuál es la principal diferencia entre

  • @Before y @BeforeClass
    • y en JUnit 5 @BeforeEach y @BeforeAll
  • @AfterClass y @AfterClass

Según JUnit Api @Before se utiliza en el siguiente caso:

Al escribir pruebas, es común encontrar que varias pruebas necesitan objetos similares creados antes de que puedan ejecutarse.

Mientras que @BeforeClass puede usarse para establecer una conexión de base de datos. ¿Pero no podría @Before hacer lo mismo?


El código marcado @Before se ejecuta antes de cada prueba, mientras que @BeforeClass ejecuta una vez antes de la prueba completa. Si su clase de prueba tiene diez pruebas, el código @Before se ejecutará diez veces, pero @BeforeClass se ejecutará solo una vez.

En general, usa @BeforeClass cuando varias pruebas necesitan compartir el mismo código de configuración computacionalmente costoso. El establecimiento de una conexión de base de datos cae en esta categoría. Puede mover el código de @BeforeClass a @Before , pero su ejecución de prueba puede llevar más tiempo. Tenga en cuenta que el código marcado @BeforeClass se ejecuta como inicializador estático, por lo tanto, se ejecutará antes de que se cree la instancia de clase de su dispositivo de prueba.

En JUnit 5 , las etiquetas @BeforeEach y @BeforeAll son los equivalentes de @Before y @BeforeClass en JUnit 4. Sus nombres son un poco más indicativos de cuándo se ejecutan, interpretados libremente: 'antes de cada prueba' y 'una vez antes de todas las pruebas '.


Antes y Antes de la Clase en JUnit

La función @Before anotación se ejecutará antes de que cada una de las funciones de prueba en la clase tenga la anotación @Test pero la función con @BeforeClass se ejecutará solo una vez antes de todas las funciones de prueba en la clase.

De manera similar, la función con @After se ejecutará después de que cada función de prueba en la clase tenga @Test pero la función con @AfterClass se ejecutará solo una vez después de todas las funciones de prueba en la clase.

SampleClass

public class SampleClass {
    public String initializeData(){
        return "Initialize";
    }

    public String processDate(){
        return "Process";
    }
 }

SampleTest

public class SampleTest {

    private SampleClass sampleClass;

    @BeforeClass
    public static void beforeClassFunction(){
        System.out.println("Before Class");
    }

    @Before
    public void beforeFunction(){
        sampleClass=new SampleClass();
        System.out.println("Before Function");
    }

    @After
    public void afterFunction(){
        System.out.println("After Function");
    }

    @AfterClass
    public static void afterClassFunction(){
        System.out.println("After Class");
    }

    @Test
    public void initializeTest(){
        Assert.assertEquals("Initailization check", "Initialize", sampleClass.initializeData() );
    }

    @Test
    public void processTest(){
        Assert.assertEquals("Process check", "Process", sampleClass.processDate() );
    }

}

Salida

Before Class
Before Function
After Function
Before Function
After Function
After Class

En junit 5

@Before = @BeforeEach
@BeforeClass = @BeforeAll
@After = @AfterEach
@AfterClass = @AfterAll

<context:annotation-config/> <!-- is used to activate the annotation for beans -->
<context:component-scan base-package="x.y.MyClass" /> <!-- is for the Spring IOC container to look for the beans in the base package. -->

El otro punto importante a tener en cuenta es que context:component-scan llama implícitamente el context:annotation-config para activar las anotaciones en beans. Bueno, si no desea que context:component-scan active implícitamente las anotaciones, puede continuar configurando el elemento annotation-config del context:component-scan en false .

Para resumir:

<context:annotation-config/> <!-- activates the annotations --> 
<context:component-scan base-package="x.y.MyClass" /> <!-- activates the annotations + register the beans by looking inside the base-package -->




java junit annotations junit4 junit5