Útmutató az 5. JUnithez

1. Áttekintés

A JUnit az egyik legnépszerűbb egységtesztelési keretrendszer a Java ökoszisztémában. A JUnit 5 verzió számos izgalmas újítást tartalmaz, a a Java 8 és újabb verziók új funkcióinak támogatása, valamint sokféle tesztelési stílust tesz lehetővé.

2. Maven-függőségek

A JUnit 5.x.0 beállítása meglehetősen egyszerű, hozzá kell adnunk a következő függőséget pom.xml:

 org.junit.jupiter junit-jupiter-motor 5.1.0 teszt 

Fontos megjegyezni, hogy ez a verzió a Java 8 működéséhez szükséges.

Sőt, mostantól közvetlen támogatás van az egység tesztek futtatására a JUnit Platformon az Eclipse-ben, valamint az IntelliJ-n. Természetesen teszteket is futtathat a Maven Test cél segítségével.

Másrészt az IntelliJ alapértelmezés szerint támogatja a JUnit 5-öt. Ezért a JUnit 5 futtatása az IntelliJ-n elég egyszerű, egyszerűen kattintson a jobb gombbal -> Futtatás vagy a Ctrl-Shift-F10.

3. Építészet

A JUnit 5 három különböző alprojekt több különböző moduljából áll:

3.1. JUnit Platform

A platform felelős a JVM tesztelési keretrendszereinek elindításáért. Stabil és hatékony interfészt határoz meg a JUnit és kliens között, például a build eszközöket.

A végső cél az, hogy ügyfelei hogyan integrálódnak könnyen a JUnittel a tesztek felfedezésében és végrehajtásában.

Ezenkívül meghatározza a TestEngine API-t a JUnit platformon futó tesztelési keretrendszer fejlesztéséhez. Ezzel testreszabhatja a harmadik fél tesztelő könyvtárait, közvetlenül a JUnit-be az egyedi TestEngine megvalósításával.

3.2. JUnit Jupiter

Ez a modul új programozási és kiterjesztési modelleket tartalmaz a tesztek írásához az 5. JUnit-ben. A JUnit 4-hez képest új megjegyzések:

  • @TestFactory - olyan módszert jelöl, amely a dinamikus tesztek tesztgyára
  • @Megjelenítendő név - meghatározza az egyedi megjelenítési nevet egy tesztosztályhoz vagy egy vizsgálati módszerhez
  • @Fészkelt - azt jelzi, hogy az annotált osztály beágyazott, nem statikus tesztosztály
  • @Címke - deklarálja a szűrési tesztek címkéit
  • @ExtendWith - az egyéni kiterjesztések regisztrálására szolgál
  • @BeforeEach - azt jelöli, hogy az annotált metódust minden tesztmódszer előtt végrehajtják (korábban @Előtt)
  • @AfterEach - azt jelöli, hogy az annotált módszer minden tesztmódszer után végrehajtásra kerül (korábban @Utána)
  • @BeforeAll - azt jelzi, hogy az annotált metódust az aktuális osztály összes tesztmódszere előtt hajtják végre (korábban @Óra előtt)
  • @Végül - azt jelzi, hogy az annotált módszer az aktuális osztály összes tesztmódszere után fog végrehajtódni (korábban @Óra után)
  • @ Letiltva - egy tesztosztály vagy módszer letiltására szolgál (korábban @Figyelmen kívül hagyni)

3.3. JUnit Vintage

Támogatja a JUnit 3 és JUnit 4 alapú tesztek futtatását a JUnit 5 platformon.

4. Alap kommentárok

Az új kommentárok megvitatásához a részt a következő csoportokba osztottuk, amelyek felelősek a végrehajtásért: a tesztek előtt, a tesztek alatt (opcionális) és a tesztek után:

4.1. @BeforeAll és @BeforeEach

Az alábbiakban bemutatunk egy példát a fő tesztesetek előtt végrehajtandó egyszerű kódra:

@BeforeAll static void setup () {log.info ("@ BeforeAll - az osztály összes tesztelési módja előtt egyszer hajt végre"); } @BeforeEach void init () {log.info ("@ BeforeEach - az osztály minden tesztmódszere előtt végrehajtja"); }

Fontos megjegyezni, hogy a metódus a @BeforeAll a kommentárnak statikusnak kell lennie, különben a kód nem áll össze.

4.2. @Megjelenítendő név és @Tiltva

Térjünk át az új teszt-opcionális módszerekre:

@DisplayName ("Sikeres teszt sikeres") @Test void testSingleSuccessTest () {log.info ("Siker"); } @Test @Disabled ("Még nincs megvalósítva") void testShowSomething () {}

Amint láthatjuk, megváltoztathatjuk a megjelenítési nevet, vagy új megjegyzéseket használva letilthatjuk a módszert megjegyzéssel.

4.3. @AfterEach és @Végül

Végül beszéljük meg a tesztek végrehajtása után a műveletekhez kapcsolódó módszereket:

@AfterEach void tearDown () {log.info ("@ AfterEach - minden tesztelési módszer után végrehajtva."); } @AfterAll static void done () {log.info ("@ AfterAll - minden tesztmódszer után végrehajtva."); }

Kérjük, vegye figyelembe ezt a módszert @Végül statikus módszernek is kell lennie.

5. Állítások és feltételezések

A JUnit 5 megpróbálja teljes mértékben kihasználni a Java 8 új szolgáltatásait, különösen a lambda kifejezéseket.

5.1. Állítások

Az állítások átkerültek ide org.junit.jupiter.api.Allertations és jelentősen javultak. Mint korábban említettük, most már lambdákat is használhat állításaiban:

@Test void lambdaExpressions () {assertTrue (Stream.of (1, 2, 3) .stream () .mapToInt (i -> i) .sum ()> 5, () -> "Az összegnek nagyobbnak kell lennie, mint 5" ); }

Bár a fenti példa triviális, a lambda kifejezés használatának egyik előnye az állítási üzenetnél az, hogy lustán kiértékelték, ami időt és erőforrásokat takaríthat meg, ha az üzenet felépítése drága.

Ma már lehetőség van állítások csoportosítására is assertAll () amely a csoporton belül minden sikertelen állítást a MultipleFailuresError:

 @Test void groupAssertions () {int [] számok = {0, 1, 2, 3, 4}; assertAll ("számok", () -> assertEquals (számok [0], 1), () -> assertEquals (számok [3], 3), () -> assertEquals (számok [4], 1)); }

Ez azt jelenti, hogy most már biztonságosabb bonyolultabb állításokat tenni, mivel pontosan meg tudja határozni az esetleges hibák pontos helyét.

5.2. Feltételezések

A feltételezéseket csak bizonyos feltételek teljesülése esetén használják tesztek futtatására. Ezt általában olyan külső körülményekre használják, amelyek szükségesek a teszt megfelelő futtatásához, de amelyek nem kapcsolódnak közvetlenül a teszteltekhez.

A feltételekkel deklarálhatsz feltételezzük Igaz (), assumeFalse (), és feltéve, hogy().

@Test void trueAssumption () {assumeTrue (5> 1); assertEquals (5 + 2, 7); } @Test void falseAssumption () {assumeFalse (5 assertEquals (2 + 2, 4)); }

Ha egy feltételezés kudarcot vall, a TestAbortedException dobják és a tesztet egyszerűen kihagyják.

A feltételezések megértik a lambda kifejezéseket is.

6. Kivétel tesztelése

A JUnit 5 kivételes tesztelésének két módja van. Mindkettő megvalósítható a használatával assertThrows () módszer:

@Test void shouldThrowException () {Dobható kivétel = assertThrows (UnsupportedOperationException.class, () -> {dobja az új UnsupportedOperationException ("Nem támogatott");}); assertEquals (kivétel.getMessage (), "Nem támogatott"); } @Test void assertThrowsException () {String str = null; assertThrows (IllegalArgumentException.class, () -> {Integer.valueOf (str);}); }

Az első példa a dobott kivétel részletesebb ellenőrzésére szolgál, a második pedig csak a kivétel típusát érvényesíti.

7. Tesztcsomagok

A JUnit 5 új funkcióinak folytatásához megpróbáljuk megismerni a több tesztosztály összesítésének koncepcióját egy tesztcsomagban, hogy ezeket együtt futtathassuk. A JUnit 5 két megjegyzéssel rendelkezik: @SelectPackages és @SelectClasses tesztcsomagok létrehozására.

Ne feledje, hogy ebben a korai szakaszban a legtöbb IDE nem támogatja ezeket a szolgáltatásokat.

Vessünk egy pillantást az elsőre:

@RunWith (JUnitPlatform.class) @SelectPackages ("com.baeldung") nyilvános osztály AllUnitTest {}

@SelectPackage a tesztcsomag futtatásakor kiválasztandó csomagok nevének megadására szolgál. Példánkban az összes teszt lefut. A második feljegyzés, @SelectClasses, a tesztcsomag futtatásakor kiválasztandó osztályok megadására szolgál:

@RunWith (JUnitPlatform.class) @SelectClasses ({AssertionTest.class, AssumptionTest.class, ExceptionTest.class}) nyilvános osztály AllUnitTest {}

Például a fenti osztály létrehoz egy csomagot, amely három tesztosztályt tartalmaz. Felhívjuk figyelmét, hogy az osztályoknak nem kell egyetlen csomagban lenniük.

8. Dinamikus tesztek

Az utolsó téma, amelyet be akarunk mutatni, a JUnit 5 dinamikus tesztek szolgáltatás, amely lehetővé teszi a futás közben generált tesztesetek deklarálását és futtatását. A statikus tesztekkel ellentétben, amelyek rögzített számú tesztesetet határoznak meg a fordítás idején, a dinamikus tesztek lehetővé teszik számunkra, hogy a futási időben dinamikusan meghatározzuk a teszteseteket.

A dinamikus tesztek előállíthatók egy gyári módszerrel, amelyhez magyarázat tartozik @TestFactory. Vessünk egy pillantást a kód példájára:

@TestFactory public Stream translateDynamicTestsFromStream () {return in.stream () .map (word -> DynamicTest.dynamicTest ("Test translate" + word, () -> {int id = in.indexOf (word); assertEquals (out. get (id), lefordít (word));})); }

Ez a példa nagyon egyszerű és könnyen érthető. Két szót akarunk lefordítani Tömb lista, nevezett ban ben és kiill. A gyári módszernek vissza kell adnia a Folyam, Gyűjtemény, Iterálható, vagy Iterátor. Esetünkben a Java 8-at választjuk Folyam.

Kérjük, vegye figyelembe, hogy @TestFactory a módszerek nem lehetnek magán- vagy statikusak. A tesztek száma dinamikus, és attól függ Tömb lista méret.

9. Következtetés

Az írás gyors áttekintést adott a JUnit 5 változásaival kapcsolatban.

Láthatjuk, hogy a JUnit 5 nagy változással rendelkezik az architektúrában, amely a platformindítóval, az integrációval a build eszközzel, az IDE-vel, más Unit tesztkeretekkel stb. Kapcsolatos. Ezenkívül a JUnit 5 jobban integrálódik a Java 8-ba, különösen a Lambdas és a Stream koncepciókba .

Az ebben a cikkben használt példák a GitHub projektben találhatók.