@Before vs @BeforeClass vs @BeforeEach vs @BeforeAll

1. Inleiding

In deze korte tutorial gaan we de verschillen tussen de @Voordat, @Voor klas, @BeforeEach en @Voor alles annotaties in JUnit 4 en 5 - met praktische voorbeelden van hoe ze te gebruiken.

We zullen ook hun kort behandelen @Na aanvullende annotaties.

Laten we beginnen met JUnit 4.

2. @Voordat

Methoden die zijn geannoteerd met de @Voordat annotaties worden voor elke test uitgevoerd. Dit is handig als we een aantal algemene code willen uitvoeren voordat we een test uitvoeren.

Laten we een voorbeeld bekijken waarin we een lijst initialiseren en enkele waarden toevoegen:

@RunWith (JUnit4.class) openbare klasse BeforeAndAfterAnnotationsUnitTest {// ... privélijstlijst; @Before public void init () {LOG.info ("opstarten"); list = nieuwe ArrayList (Arrays.asList ("test1", "test2")); } @After public void teardown () {LOG.info ("teardown"); lijst.clear (); }}

Merk op dat we ook een andere methode hebben toegevoegd die is geannoteerd met @Na om de lijst te wissen na het uitvoeren van elke test.

Laten we daarna enkele tests toevoegen om de grootte van onze lijst te controleren:

@Test public void whenCheckingListSize_thenSizeEqualsToInit () {LOG.info ("test uitvoeren"); assertEquals (2, list.size ()); list.add ("nog een test"); } @Test public void whenCheckingListSizeAgain_thenSizeEqualsToInit () {LOG.info ("bezig met een andere test"); assertEquals (2, list.size ()); list.add ("nog een andere test"); }

In dit geval, Het is cruciaal om ervoor te zorgen dat de testomgeving correct is ingesteld voordat elke test wordt uitgevoerd aangezien de lijst wordt gewijzigd tijdens elke testuitvoering.

Als we de logoutput bekijken, kunnen we controleren of de in het en scheuren methoden werden eenmaal per test uitgevoerd:

... opstarten ... nog een test uitvoeren ... teardown ... opstarten ... test uitvoeren ... teardown

3. @Voor klas

Als we voor elke test een dure gemeenschappelijke operatie willen uitvoeren, het verdient de voorkeur om het slechts één keer uit te voeren voordat u alle tests uitvoert met @Voor klas. Enkele voorbeelden van veelvoorkomende dure operaties zijn het tot stand brengen van een databaseverbinding of het opstarten van een server.

Laten we een eenvoudige testklasse maken die het maken van een databaseverbinding simuleert:

@RunWith (JUnit4.class) openbare klasse BeforeClassAndAfterClassAnnotationsUnitTest {// ... @BeforeClass openbare statische leegte setup () {LOG.info ("opstarten - DB-verbinding maken"); } @AfterClass openbare statische leegte tearDown () {LOG.info ("DB-verbinding wordt gesloten"); }}

Let erop dat deze methoden moeten statisch zijn, zodat ze worden uitgevoerd voordat de tests van de klas worden uitgevoerd.

Laten we, zoals we eerder hebben gedaan, ook enkele eenvoudige tests toevoegen:

@Test public void simpleTest () {LOG.info ("eenvoudige test"); } @Test public void anotherSimpleTest () {LOG.info ("nog een simpele test"); }

Als we deze keer de logboekuitvoer bekijken, kunnen we controleren of het opstelling en scheuren methoden werden slechts één keer uitgevoerd:

... opstarten - DB-verbinding maken ... eenvoudige test ... nog een eenvoudige test ... DB-verbinding sluiten

4. @BeforeEach en @Voor alles

@BeforeEach en @Voor alles zijn de JUnit 5-equivalenten van @Voordat en @Voor klas. Deze annotaties zijn hernoemd met duidelijkere namen om verwarring te voorkomen.

Laten we onze vorige klassen dupliceren met behulp van deze nieuwe annotaties, te beginnen met de @BeforeEach en @Na elke annotaties:

@RunWith (JUnitPlatform.class) klasse BeforeEachAndAfterEachAnnotationsUnitTest {// ... privélijstlijst; @BeforeEach void init () {LOG.info ("opstarten"); list = nieuwe ArrayList (Arrays.asList ("test1", "test2")); } @AfterEach void teardown () {LOG.info ("teardown"); lijst.clear (); } // ...}

Als we de logboeken controleren, kunnen we bevestigen dat het op dezelfde manier werkt als met het @Voordat en @Na annotaties:

... opstarten ... nog een test uitvoeren ... teardown ... opstarten ... test uitvoeren ... teardown

Laten we tot slot hetzelfde doen met de andere testklasse om het @Voor alles en @Ten slotte annotaties in actie:

@RunWith (JUnitPlatform.class) openbare klasse BeforeAllAndAfterAllAnnotationsUnitTest {// ... @BeforeAll openbare statische leegte setup () {LOG.info ("opstarten - DB-verbinding maken"); } @AfterAll openbare statische leegte tearDown () {LOG.info ("DB-verbinding wordt gesloten"); } // ...}

En de uitvoer is hetzelfde als bij de oude annotatie:

... opstarten - DB-verbinding maken ... eenvoudige test ... nog een eenvoudige test ... DB-verbinding sluiten

5. Conclusie

In dit artikel hebben we de verschillen tussen de @Voordat, @Voor klas, @BeforeEach en @Voor alles annotaties in JUnit en wanneer ze allemaal moeten worden gebruikt.

Zoals altijd is de volledige broncode van de voorbeelden beschikbaar op GitHub.