Diferença entre @Before, @BeforeClass, @BeforeEach e @BeforeAll


432

Qual é a principal diferença entre

  • @Before e @BeforeClass
    • e na JUnit 5 @BeforeEache@BeforeAll
  • @After e @AfterClass

De acordo com o JUnit, a API @Before é usada no seguinte caso:

Ao escrever testes, é comum descobrir que vários testes precisam de objetos semelhantes criados antes de serem executados.

Considerando que @BeforeClasspode ser usado para estabelecer uma conexão com o banco de dados. Mas não poderia @Beforefazer o mesmo?

Respostas:


624

O código marcado @Beforeé executado antes de cada teste, enquanto @BeforeClassé executado uma vez antes de todo o equipamento de teste. Se sua classe de teste tiver dez testes, o @Beforecódigo será executado dez vezes, mas @BeforeClassserá executado apenas uma vez.

Em geral, você usa @BeforeClassquando vários testes precisam compartilhar o mesmo código de configuração computacionalmente caro. Estabelecer uma conexão com o banco de dados se enquadra nessa categoria. Você pode mover o código de @BeforeClasspara @Before, mas sua execução de teste pode levar mais tempo. Observe que o código marcado @BeforeClassé executado como inicializador estático, portanto, será executado antes da criação da instância de classe do seu equipamento de teste.

Na JUnit 5 , as tags @BeforeEache @BeforeAllsão equivalentes @Beforee @BeforeClassna JUnit 4. Seus nomes são um pouco mais indicativos de quando são executados, vagamente interpretados: 'antes de cada teste' e 'uma vez antes de todos os testes'.


4
Ah, agora o exemplo com a conexão DB faz sentido. Obrigado!
user1170330

6
@pacoverflow @BeforeClasé estático. É executado antes que as instâncias da classe de teste sejam criadas.
dasblinkenlight

1
Tenha em mente que quando você usa @BeforeClass suas necessidades método / parâmetro a ser estática
tiagocarvalho92

Não está diretamente relacionado, mas é uma maneira de calcular o contador 'Tests by Category' .
Bsquare ℬℬ

Acrescentarei apenas que @BeforeAllpode não ser estático e chamo cada nova execução de instância de teste. Veja a resposta correspondente stackoverflow.com/a/55720750/1477873
Sergey

124

As diferenças entre cada anotação são:

+-------------------------------------------------------------------------------------------------------+
¦                                       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.                        ¦              ¦             ¦
+-------------------------------------------------------------------------------------------------------+

A maioria das anotações nas duas versões é a mesma, mas poucas diferem.

Referência

Ordem de execução.

Caixa tracejada -> anotação opcional.

insira a descrição da imagem aqui


10

Before e BeforeClass no JUnit

A @Beforeanotação da função será executada antes de cada uma das funções de teste da classe ter @Testanotação, mas a função com @BeforeClassserá executada apenas uma vez antes de todas as funções de teste da classe.

Da mesma forma, a função com @Afteranotação será executada após cada função de teste na classe ter @Testanotação, mas a função com @AfterClassserá executada apenas uma vez após todas as funções de teste na classe.

SampleClass

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

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

Teste de amostra

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() );
    }

}

Resultado

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

Em 5 de junho

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

1
Muito bom exemplo.
precisa saber é o seguinte

2
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 a

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())
    }
}
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.