Diferencia entre @Before, @BeforeClass, @BeforeEach y @BeforeAll

¿Cuál es la principal diferencia entre

• @Before y @BeforeClass
  • y en JUnit 5 @BeforeEachy@BeforeAll
• @After y @AfterClass

De acuerdo con el 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 @BeforeClassse puede utilizar para establecer una conexión de base de datos. ¿Pero no podría @Beforehacer lo mismo?

El código marcado @Beforese ejecuta antes de cada prueba, mientras que se @BeforeClassejecuta una vez antes de todo el dispositivo de prueba. Si su clase de prueba tiene diez pruebas, el @Beforecódigo se ejecutará diez veces, pero @BeforeClasssolo se ejecutará una vez.

En general, se usa @BeforeClasscuando múltiples pruebas necesitan compartir el mismo código de configuración computacionalmente costoso. Establecer una conexión de base de datos cae en esta categoría. Puede mover el código desde @BeforeClassdentro @Before, pero su prueba de funcionamiento puede tomar más tiempo. Tenga en cuenta que el código marcado @BeforeClassse 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 @BeforeEachy @BeforeAllson equivalentes @Beforey @BeforeClassen 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'.

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 difieren.

Referencia

Orden de ejecución.

Cuadro punteado -> anotación opcional.

Antes y antes Clase en JUnit

La @Beforeanotación de la función se ejecutará antes de cada una de las funciones de prueba en la clase que tenga @Testanotación, pero la función con @BeforeClassse ejecutará solo una vez antes de todas las funciones de prueba en la clase.

Del mismo modo, la función con @Afteranotación se ejecutará después de cada una de las funciones de prueba en la clase que tenga @Testanotación, pero la función con @AfterClassse 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";
    }
 }

Prueba de muestra

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 junio 5

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

import org.junit.Assert
import org.junit.Before
import org.junit.BeforeClass
import org.junit.Test

class FeatureTest {
    companion object {
        private lateinit var heavyFeature: HeavyFeature
        @BeforeClass
        @JvmStatic
        fun beforeHeavy() {
            heavyFeature = HeavyFeature()
        }
    }

    private lateinit var feature: Feature

    @Before
    fun before() {
        feature = Feature()
    }

    @Test
    fun testCool() {
        Assert.assertTrue(heavyFeature.cool())
        Assert.assertTrue(feature.cool())
    }

    @Test
    fun testWow() {
        Assert.assertTrue(heavyFeature.wow())
        Assert.assertTrue(feature.wow())
    }
}

Igual que

import org.junit.Assert
import org.junit.Test

 class FeatureTest {
    companion object {
        private val heavyFeature = HeavyFeature()
    }

    private val feature = Feature()

    @Test
    fun testCool() {
        Assert.assertTrue(heavyFeature.cool())
        Assert.assertTrue(feature.cool())
    }

    @Test
    fun testWow() {
        Assert.assertTrue(heavyFeature.wow())
        Assert.assertTrue(feature.wow())
    }
}