streamalism.org

1. Áttekintés

Ebben az oktatóanyagban kitérünk a a Mockito könyvtár jegyzetei – @Mock, @Kém, @Foglyul ejtő, és @InjectMocks.

További Mockito jóságért nézze meg az itt látható sorozatot.

2. Engedélyezze a Mockito kommentárokat

Mielőtt továbbmennénk, vizsgáljuk meg a Mockito-tesztek segítségével a kommentárok használatának engedélyezésének különböző módjait.

2.1. MockitoJUnitRunner

Az első lehetőségünk az, hogy jegyezze fel a JUnit tesztet a-val MockitoJUnitRunner mint a következő példában:

@RunWith (MockitoJUnitRunner.class) nyilvános osztály MockitoAnnotationTest {...}

2.2. MockitoAnnotations.initMocks ()

Alternatív megoldásként megtehetjük programozottan engedélyezze a Mockito kommentárokat valamint hivatkozással MockitoAnnotations.initMocks ():

@A nyilvános void előtt init () {MockitoAnnotations.initMocks (this); }

2.3. MockitoJUnit.rule ()

Végül, használhatjuk a MockitoJUnit.rule ()az alábbiak szerint:

public class MockitoInitWithMockitoJUnitRuleUnitTest {@Rule public MockitoRule initRule = MockitoJUnit.rule (); ...}

Ebben az esetben emlékeznünk kell a szabályunk megalkotására nyilvános.

3. @Mock Megjegyzés

A Mockito-ban a leggyakrabban használt annotáció a @Mock. Tudjuk használni @Mock gúnyos példányok létrehozása és injektálása hívás nélkül Mockito.mock manuálisan.

A következő példában - létrehozunk egy csúfoltat Tömb lista kézi módon, használat nélkül @Mock kommentár:

@Test public void whenNotUseMockAnnotation_thenCorrect () {List mockList = Mockito.mock (ArrayList.class); mockList.add ("egy"); Mockito.verify (mockList) .add ("egy"); assertEquals (0, mockList.size ()); Mockito.when (mockList.size ()). AkkorReturn (100); assertEquals (100, mockList.size ()); }

És most ugyanezt tesszük, de a gúttal a @Mock kommentár:

@Mock List mockedList; @Test public void whenUseMockAnnotation_thenMockIsInjected () {mockedList.add ("one"); Mockito.verify (mockedList) .add ("egy"); assertEquals (0, mockedList.size ()); Mockito.when (mockedList.size ()). AkkorReturn (100); assertEquals (100, mockedList.size ()); }

Vegye figyelembe, hogy - mindkét példában kölcsönhatásba lépünk a gúnnyal, és ellenőrizzük ezeknek a kölcsönhatásoknak a néhányat - csak azért, hogy megbizonyosodjunk arról, hogy a gúny helyesen viselkedik-e.

4. @Kém Megjegyzés

Most - nézzük meg, hogyan kell használni @Kém jegyzet egy meglévő példány kémleléséhez.

A következő példában - létrehozunk egy kém a Lista a régi módon használat nélkül @Kém kommentár:

@Test public void whenNotUseSpyAnnotation_thenCorrect () {List spyList = Mockito.spy (new ArrayList ()); spyList.add ("egy"); spyList.add ("kettő"); Mockito.verify (spyList) .add ("egy"); Mockito.verify (spyList) .add ("kettő"); assertEquals (2, spyList.size ()); Mockito.doReturn (100) .mikor (spyList) .size (); assertEquals (100, spyList.size ()); }

Most tegyük ugyanezt - kémkedjünk a listán -, de tegyük a @Kém kommentár:

@Spy List spiedList = new ArrayList (); @Test public void whenUseSpyAnnotation_thenSpyIsInjectedCorrectly () {spiedList.add ("one"); spiedList.add ("kettő"); Mockito.verify (spiedList) .add ("egy"); Mockito.verify (spiedList) .add ("kettő"); assertEquals (2, spiedList.size ()); Mockito.doReturn (100) .mikor (kémlista) .size (); assertEquals (100, spiedList.size ()); }

Figyelje meg, hogyan, mint korábban - itt is kapcsolatba lépünk a kémmel, hogy megbizonyosodjunk arról, hogy az megfelelően viselkedik-e. Ebben a példában:

• Használt a igazi módszer spiedList.add () elemeket hozzáadni a spiedList.
• Megszúrt a módszer, a metódus spiedList.size () visszatérni 100 ahelyett 2 felhasználásával Mockito.doReturn ().

5. @Foglyul ejtő Megjegyzés

Következő - nézzük meg, hogyan kell használni a @Foglyul ejtő annotáció egy ArgumentCaptor példa.

A következő példában - létrehozunk egy ArgumentCaptor a régi módon használat nélkül @Foglyul ejtő kommentár:

@Test public void whenNotUseCaptorAnnotation_thenCorrect () {List mockList = Mockito.mock (List.class); ArgumentCaptor arg = ArgumentCaptor.forClass (String.class); mockList.add ("egy"); Mockito.verify (mockList) .add (arg.capture ()); assertEquals ("egy", arg.getValue ()); }

Nézzük most kihasználni @Foglyul ejtőugyanezen célból - létrehozni egy ArgumentCaptor példa:

@Mock List mockedList; @Captor ArgumentCaptor argCaptor; @Test public void whenUseCaptorAnnotation_thenTheSam () {mockedList.add ("one"); Mockito.verify (mockedList) .add (argCaptor.capture ()); assertEquals ("egy", argCaptor.getValue ()); }

Figyelje meg, hogyan válik a teszt egyszerűbbé és olvashatóbbá, amikor kivesszük a konfigurációs logikát.

6. @InjectMocks Megjegyzés

Most - beszéljük meg, hogyan kell használni @InjectMocks annotáció - az álmezők automatikus injektálása a tesztelt objektumba.

A következő példában - használjuk @InjectMocks hogy beadja a gúnyt wordMap ba,-be MyDictionarydic:

@Mock Map wordMap; @InjectMocks MyDictionary dic = új MyDictionary (); @Test public void whenUseInjectMocksAnnotation_thenCorrect () {Mockito.when (wordMap.get ("aWord")).. assertEquals ("aMeaning", dic.getMeaning ("aWord")); }

És itt van az osztály MyDictionary:

nyilvános osztály MyDictionary {Map wordMap; nyilvános Saját szótár () {wordMap = new HashMap (); } public void add (végső karakterlánc-szó, végső karakterlánc-jelentés) {wordMap.put (szó, jelentés); } public String getMeaning (utolsó karakterlánc szó) {return wordMap.get (word); }} 

7. Gúny injektálása kémré

A fenti teszthez hasonlóan érdemes kigúnyot injektálnunk egy kémbe:

@Mock Map wordMap; @Spy Saját szótár spyDic = új Saját szótár ();

Mockito azonban nem támogatja a gúnyok injektálását a kémekbe, és a következő vizsgálati eredmények kivételével:

@Test public void whenUseInjectMocksAnnotation_thenCorrect () {Mockito.when (wordMap.get ("aWord")). ThenReturn ("aMeaning"); assertEquals ("aMeaning", spyDic.getMeaning ("aWord")); }

Ha egy kémet akarunk használni, akkor manuálisan beadhatjuk a modellt egy konstruktoron keresztül:

Saját szótár (Map wordMap) {this.wordMap = wordMap; }

A kommentár használata helyett most manuálisan létrehozhatjuk a kémet:

@Mock Map wordMap; MyDictionary spyDic; @A nyilvános void előtt init () {MockitoAnnotations.initMocks (this); spyDic = Mockito.spy (új MyDictionary (wordMap)); } 

A teszt most sikeres lesz.

8. Belefutás az NPE-be annotáció használata közben

Gyakran előfordulhat belefutni NullPointerException amikor megpróbáljuk ténylegesen használni a jelöléssel ellátott példányt @Mock vagy @Kém:

public class MockitoAnnotationsUninitializedUnitTest {@Mock List mockedList; @Test (várható = NullPointerException.class) public void whenMockitoAnnotationsUninialial_thenNPEThrown () {Mockito.when (mockedList.size ()). ThenReturn (1); }}

Legtöbbször ez egyszerűen azért történik, mert megfeledkeztünk a Mockito kommentárok megfelelő engedélyezéséről.

Tehát szem előtt kell tartanunk, hogy minden egyes alkalommal, amikor a Mockito megjegyzéseket akarjuk használni, meg kell tennünk egy további lépést és inicializálnunk kell őket, ahogy azt korábban már kifejtettük.

9. Megjegyzések

Végül - itt vannak néhány jegyzet a Mockito kommentárokról:

• A Mockito kommentárjai minimalizálják az ismétlődő ál-létrehozási kódot
• A teszteket olvashatóbbá teszik
• @InjectMocks szükséges mindkettő injekciójához @Kém és @Mock példányok

10. Következtetés

Ebben a gyors bemutatóban bemutattuk a annotációk a Mockito könyvtárban.

Ezeknek a példáknak a megvalósítása megtalálható a GitHub-on. Ez egy Maven projekt, ezért könnyen importálhatónak és futtathatónak kell lennie.

És természetesen a további Mockito jóság érdekében nézze meg az itteni sorozatot.