Začíname s programami Mockito @Mock, @Spy, @Captor a @InjectMocks

1. Prehľad

V tomto výučbe sa budeme venovať anotácie knižnice Mockito@Mock, @ Spy, @ Captora @InjectMocks.

Ak chcete získať viac dobrôt Mockito, pozrite sa na sériu tu.

2. Povoľte anotácie Mockito

Skôr ako pôjdeme ďalej, preskúmajme rôzne spôsoby, ako povoliť použitie anotácií pomocou testov Mockito.

2.1. MockitoJUnitRunner

Prvá možnosť, ktorú máme, je anotovať test JUnit pomocou a MockitoJUnitRunner ako v nasledujúcom príklade:

@RunWith (MockitoJUnitRunner.class) verejná trieda MockitoAnnotationTest {...}

2.2. MockitoAnnotations.initMocks ()

Prípadne môžeme povoliť programové anotácie Mockito tiež vyvolaním MockitoAnnotations.initMocks ():

@Before public void init () {MockitoAnnotations.initMocks (this); }

2.3. MockitoJUnit.rule ()

Nakoniec môžeme použiť a MockitoJUnit.rule ()ako je uvedené nižšie:

verejná trieda MockitoInitWithMockitoJUnitRuleUnitTest {@Rule public MockitoRule initRule = MockitoJUnit.rule (); ...}

V takom prípade musíme pamätať na to, aby sme stanovili svoje pravidlo verejné.

3. @Mock Anotácia

Najbežnejšie používaná anotácia v dokumente Mockito je @Mock. Môžeme použiť @Mock vytvoriť a vložiť vysmievané inštancie bez nutnosti volať Mockito.mock ručne.

V nasledujúcom príklade - vytvoríme posmech ArrayList manuálnym spôsobom bez použitia @Mock anotácia:

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

A teraz urobíme to isté, ale vpichneme falošnú injekciu pomocou @Mock anotácia:

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

Všimnite si, ako - v obidvoch príkladoch interagujeme s falošnými vzorkami a overujeme niektoré z týchto interakcií - len aby sme sa ubezpečili, že sa falošný model správa správne.

4. @ Spy Anotácia

Teraz - pozrime sa, ako sa používa @ Spy anotácia špehovať existujúcu inštanciu.

V nasledujúcom príklade - vytvoríme špióna a Zoznam starým spôsobom bez použitia @ Spy anotácia:

@ Test public void whenNotUseSpyAnnotation_thenCorrect () {List spyList = Mockito.spy (new ArrayList ()); spyList.add ("jeden"); spyList.add ("dva"); Mockito.verify (spyList) .add ("jeden"); Mockito.verify (spyList) .add ("dva"); assertEquals (2, spyList.size ()); Mockito.doReturn (100) .when (spyList) .size (); assertEquals (100, spyList.size ()); }

Urobme teraz to isté - špehujme v zozname - ale urobme to pomocou @ Spy anotácia:

@Spy List spiedList = nový ArrayList (); @Test public void whenUseSpyAnnotation_thenSpyIsInjectedCorrectly () {spiedList.add ("one"); spiedList.add ("dva"); Mockito.verify (spiedList) .add ("jeden"); Mockito.verify (spiedList) .add ("dva"); assertEquals (2, spiedList.size ()); Mockito.doReturn (100) .when (spiedList) .size (); assertEquals (100, spiedList.size ()); }

Všimnite si, ako - predtým, tu interagujeme so špiónom, aby sme sa ubezpečili, že sa chová správne. V tomto príklade sme:

  • Použité reálny metóda spiedList.add () pridať prvky do súboru spiedList.
  • Podrazený metóda spiedList.size () vrátiť sa 100 namiesto 2 použitím Mockito.doReturn ().

5. @ Captor Anotácia

Ďalej - pozrime sa, ako používať @ Captor anotácia na vytvorenie ArgumentCaptor inštancia.

V nasledujúcom príklade - vytvoríme ArgumentCaptor starým spôsobom bez použitia @ Captor anotácia:

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

Poďme teraz použiť @ Captorna ten istý účel - vytvoriť ArgumentCaptor inštancia:

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

Všimnite si, ako sa test stáva jednoduchším a čitateľnejším, keď odstránime konfiguračnú logiku.

6. @InjectMocks Anotácia

Teraz - poďme diskutovať o tom, ako používať @InjectMocks anotácia - automatické vloženie falošných polí do testovaného objektu.

V nasledujúcom príklade - používame @InjectMocks podať falošnú injekciu wordMap do MyDictionarydic:

@Mock Mapa wordMap; @InjectMocks MyDictionary dic = nový MyDictionary (); @Test public void whenUseInjectMocksAnnotation_thenCorrect () {Mockito.when (wordMap.get ("aWord")). ThenReturn ("aMeaning"); assertEquals ("aMeaning", dic.getMeaning ("aWord")); }

A tu je trieda MyDictionary:

verejná trieda MyDictionary {Mapa wordMap; public MyDictionary () {wordMap = new HashMap (); } public void add (konečné reťazcové slovo, konečný význam reťazca) {wordMap.put (slovo, význam); } public String getMeaning (konečné reťazcové slovo) {návrat wordMap.get (slovo); }} 

7. Injekčné vysmievanie sa špiónovi

Podobne ako v predchádzajúcom teste, aj my by sme možno chceli napodobniť špióna:

@Mock Mapa wordMap; @Spy MyDictionary spyDic = nový MyDictionary ();

Mockito však nepodporuje injekčné podvádzanie špiónov, a nasledujúce výsledky testov vo výnimke:

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

Ak chceme použiť faloš so špiónom, môžeme ho falošne vložiť pomocou konštruktora:

MyDictionary (mapa wordMap) {this.wordMap = wordMap; }

Namiesto použitia anotácie teraz môžeme špióna vytvoriť ručne:

@Mock Mapa wordMap; MyDictionary spyDic; @Before public void init () {MockitoAnnotations.initMocks (this); spyDic = Mockito.spy (nový MyDictionary (wordMap)); } 

Test teraz prejde.

8. Spustenie NPE pri používaní anotácie

Často môžeme naraziť NullPointerException keď sa pokúsime skutočne použiť inštanciu anotovanú pomocou @Mock alebo @ Spy:

verejná trieda MockitoAnnotationsUninitializedUnitTest {@Mock List mockedList; @Test (očakáva sa = NullPointerException.class) public void whenMockitoAnnotationsUninitialized_thenNPEThrown () {Mockito.when (mockedList.size ()). ThenReturn (1); }}

Väčšinou sa to deje jednoducho preto, že sme zabudli správne povoliť anotácie Mockito.

Musíme si teda uvedomiť, že zakaždým, keď chceme použiť anotácie Mockito, musíme urobiť ďalší krok a inicializovať ich, ako sme už vysvetlili predtým.

9. Poznámky

Nakoniec - tu sú nejaké poznámky o anotáciách Mockito:

  • Mockitove anotácie minimalizujú opakujúci sa falošný kód na vytvorenie
  • Vďaka nim sú testy čitateľnejšie
  • @InjectMocks je nevyhnutný pre injekčné podanie oboch @ Spy a @Mock inštancie

10. Záver

V tomto rýchlom výučbe sme si ukázali základy anotácie v knižnici Mockito.

Implementáciu všetkých týchto príkladov nájdete na GitHub. Toto je projekt Maven, takže by malo byť ľahké ho importovať a spustiť tak, ako je.

A samozrejme, pre viac dobrôt Mockito, sa pozrite na sériu tu.


$config[zx-auto] not found$config[zx-overlay] not found