Cadrul Mockito oferă o varietate de metode, cum ar fi mock(), verify(), when(), etc., utilizate pentru a testa aplicațiile Java. Utilizarea acestor metode predefinite face testarea foarte ușoară.

O scurtă descriere a metodelor Mockito este dată mai jos:

cum să recuperezi aplicațiile ascunse

Metoda mockito mock().

Este folosit pentru a crea obiecte simulate ale unei clase sau interfețe date. Mockito conține cinci a-și bate joc() metode cu argumente diferite. Când nu am atribuit nimic mock-urilor, acestea vor returna valorile implicite. Toate cele cinci metode îndeplinesc aceeași funcție de a batjocori obiectele.

Următoarele sunt metodele mock() cu diferiți parametri:

metoda mock() cu Class:Este folosit pentru a crea obiecte simulate ale unei clase concrete sau ale unei interfețe. Ia ca parametru o clasă sau un nume de interfață.
Sintaxă: simulare (clasa de clasăToMock)metoda mock() cu Răspuns:Este folosit pentru a crea obiecte simulate ale unei clase sau interfețe cu o procedură specifică. Este o metodă simulată avansată, care poate fi utilizată atunci când lucrați cu sisteme vechi. Ia Answer ca parametru împreună cu numele clasei sau al interfeței. Răspunsul este o enumerare de răspunsuri simulate preconfigurate.
Sintaxă: mock (Clasa de clasăToMock, Răspuns implicitRăspuns)metoda mock() cu MockSettings:Este folosit pentru a crea obiecte simulate cu unele setări non-standard. Este nevoie de MockSettings ca un parametru de setare suplimentar împreună cu numele clasei sau al interfeței. MockSettings permite crearea de obiecte simulate cu setări suplimentare.
Sintaxă: mock(Clasa de clasăToMock, MockSettings mockSettings)metoda mock() cu ReturnValues:Permite crearea de obiecte simulate ale unei clase sau interfețe date. Acum, este depreciat, deoarece ReturnValues ​​sunt înlocuite cu Answer.
Sintaxă: mock(Clasa clasăToMock, ReturnValues ​​returnValues)metoda mock() cu String:Este folosit pentru a crea obiecte simulate prin specificarea numelor simulate. În depanare, denumirea obiectelor simulate poate fi utilă, în timp ce este o alegere proastă folosind codul mare și complex.
Sintaxă: mock(Clasa de clasăToMock, Nume șir)

Următorul fragment de cod arată cum se utilizează a-și bate joc() metodă:

 ToDoService doService = mock(ToDoService.class); 

Metoda Mockito when().

Permite metode de împingere. Ar trebui folosit atunci când vrem să ne batem joc pentru a returna valori specifice atunci când anumite metode sunt apelate. In termeni simpli, ' Când metoda XYZ() este numită, apoi întoarce ABC.' Este folosit mai ales atunci când există o anumită condiție de executat.

Sintaxă: când(T methodCall)

Următorul fragment de cod arată cum se utilizează metoda when():

 when(mock.someCode ()).thenReturn(5); 

În codul de mai sus, apoiReturn() este folosit mai ales cu când() metodă.

Metoda Mockito verify().

The verifica() metoda este folosită pentru a verifica dacă unele metode specificate sunt apelate sau nu. În termeni simpli, validează un anumit comportament care s-a întâmplat o dată într-un test. Este folosit în partea de jos a codului de testare pentru a se asigura că sunt apelate metodele definite.

Cadrul Mockito ține evidența tuturor apelurilor de metodă cu parametrii lor pentru obiectele batjocoritoare. După batjocură, putem verifica dacă condițiile definite sunt îndeplinite sau nu prin utilizarea metodei verify(). Acest tip de testare este uneori cunoscut ca testarea comportamentală. Verifică dacă o metodă este apelată cu parametrii potriviți în loc să verifice rezultatul unui apel de metodă.

Metoda verify() este folosită și pentru a testa numărul de invocari. Deci, putem testa numărul exact de invocări folosind metoda ori, metoda cel puțin o dată, și cel mult metoda pentru o metodă batjocorită.

Există două tipuri de metode verify() disponibile în clasa Mockito, care sunt prezentate mai jos:

metoda verify():Verifică un anumit comportament s-a întâmplat o dată.
Sintaxă: verifica (T batjocorește)metoda verify() cu VerificationMode:Verifică un comportament care s-a întâmplat cel puțin o dată, de numărul exact de ori sau niciodată.
Sintaxă: verifica (T mock, modul VerificationMode)

Metoda Mockito spy().

Mockito oferă o metodă de a bate joc parțial de un obiect, care este cunoscut sub numele de spion metodă. Când utilizați metoda spionajului, există un obiect real și spionii sau stub-urile sunt create din acel obiect real. Dacă nu blocăm o metodă folosind spion, aceasta va apela comportamentul real al metodei. Funcția principală a metodei spy() este aceea că suprascrie metodele specifice ale obiectului real. Una dintre funcțiile metodei spy() este aceea de a verifica invocarea unei anumite metode.

Există două tipuri de metode spion() disponibile în clasa Mockito:

metoda spion():Acesta creează un spion al obiectului real. Metoda de spionaj apelează metodele reale, cu excepția cazului în care acestea sunt blocate. Ar trebui să folosim spionii adevărați cu atenție și ocazional, de exemplu, atunci când avem de-a face cu codul moștenit.
Sintaxă: spion (obiect T)metoda spy() cu Clasa:Acesta creează un obiect spion bazat pe clasă în loc de un obiect. Metoda spy(T object) este deosebit de utilă pentru spionarea claselor abstracte, deoarece acestea nu pot fi instanțiate.
Sintaxă: spion (clasa de clasaToSpy)

Următorul fragment de cod arată cum să utilizați metoda spy():

 List spyArrayList = spy(ArrayList.class); 

Metoda Mockito reset().

Metoda Mockito reset() este folosită pentru a reseta mock-urile. Este folosit în principal pentru lucrul cu recipientele injectate. De obicei, metoda reset() are ca rezultat un cod lung și teste slabe. Este mai bine să creați modele noi decât să utilizați metoda reset(). De aceea metoda reset() este rar folosită în testare.

Semnătura metodei reset() este:

ce face un calculator rapid

 public static void reset(T ... mocks) { MOCKITO_CORE.reset(mocks); } 

Mocki pentru metoda verifyNoMoreInteractions().

Este folosit pentru a verifica dacă oricare dintre simulacrele date au interacțiuni neverificate. Putem folosi această metodă după ce verificăm toate mock-urile, pentru a ne asigura că nimic altceva nu a fost invocat pe mock-uri. De asemenea, detectează invocările neverificate care apar înainte de metoda de testare, de exemplu, în setup(), metoda @Before sau constructor. Este o metodă opțională și nu trebuie să o folosim în fiecare test.

Semnătura metodei verifyNoMoreInteractions() este:

 public static void verifyNoMoreInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } 

Metoda Mockito verifyZeroInteractions().

Acesta verifică că nu a avut loc nicio interacțiune pe macurile date. De asemenea, detectează invocările care au avut loc înainte de metoda de testare, de exemplu, în setup(), metoda @Before sau constructor.

Semnătura metodei verifyZeroInteractions() este:

 public static void verifyZeroInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } 

Metoda Mockito doThrow().

Este folosit atunci când se blochează o metodă void pentru a arunca o excepție. Acesta creează o nouă instanță de excepție pentru fiecare invocare a metodei. Există două tipuri de metode doThrow() disponibile în clasa Mockito cu parametri diferiți, după cum se arată mai jos:

Metoda doThrow() cu Throwable:Această metodă este folosită atunci când dorim să blocăm o metodă void cu o excepție. Sintaxă: doThrow(Throwable toBeThrown)
Semnătura metodei doThrow() este:

 public static Stubber doThrow(Throwable toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsException(toBeThrown)); } 

Metoda doThrow() cu Class:Această metodă este folosită atunci când dorim să blocăm o metodă void pentru a arunca o excepție a unei clase specificate.
Sintaxă: doThrow (Clasa de Aruncat)
Semnătura metodei doThrow() este:

 public static Stubber doThrow(Class toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsExceptionClass(toBeThrown)); } 

Mockito metoda doCallRealMethod().

Este folosit atunci când dorim să apelăm implementarea reală a unei metode. Cu alte cuvinte, este folosit pentru a crea imitații parțiale ale unui obiect. Este folosit în situații rare, cum ar fi apelarea metodelor reale. Este similar cu metoda spy() și singura diferență este că are ca rezultat cod complex.

Semnătura metodei doCallRealMethod() este:

 public static Stubber doCallRealMethod() { return MOCKITO_CORE.doAnswer(new CallsRealMethods()); } 

Metoda Mockito doAnswer().

Este folosit atunci când dorim să blocăm o metodă void cu un tip de răspuns generic. Semnătura metodei doAnswer() este:

 public static Stubber doAnswer(Answer answer) { return MOCKITO_CORE.doAnswer(answer); } 

Metoda Mockito doNothing().

Este folosit pentru a seta metode void pentru a nu face nimic. Metoda doNothing() este folosită în situații rare. În mod implicit, metodele void din instanțe simulate nu fac nimic, adică nu se execută nicio sarcină.

Semnătura metodei doNothing() este:

 public static Stubber doNothing() { return MOCKITO_CORE.doAnswer(new DoesNothing()); } 

Metoda Mockito doReturn().

Este folosit în acele rare ocazii când nu putem folosi Mockito.when(obiect). Metoda Mockito.when(object) este întotdeauna sugerată pentru stubbing, deoarece este sigură pentru tipul de argument și mai ușor de citit în comparație cu metoda doReturn().

Semnătura metodei doReturn() este:

 public static Stubber doReturn(Object toBeReturned) { return MOCKITO_CORE.doAnswer(new Returns(toBeReturned)); } 

Metoda Mockito inOrder().

Este folosit pentru a crea obiecte care permit verificarea falselor într-o anumită ordine. Verificarea făcută în ordine este mai flexibilă, deoarece nu trebuie să verificăm toate interacțiunile. Trebuie să verificăm doar acele interacțiuni care sunt interesate de testare (în ordine). De asemenea, putem folosi metoda inOrder() pentru a crea un obiect inOrder care trece false care sunt relevante pentru verificarea în ordine.

Semnătura metodei Mockito.inOrder() este:

 public static InOrder inOrder(Object... mocks) { return MOCKITO_CORE.inOrder(mocks); } 

Metoda Mockito ignoreStubs().

Este folosit pentru a ignora metodele de ciocănire ale macurilor date pentru verificare. Este util cu metodele verifyNoMoreInteractions() sau verificare inOrder(). De asemenea, ajută la evitarea verificării redundante a apelurilor blocate.

Semnătura metodei ignoreStubs() este:

 public static Object[] ignoreStubs(Object... mocks) { return MOCKITO_CORE.ignoreStubs(mocks); } 

Metoda Mockito times().

Este folosit pentru a verifica numărul exact de invocări de metodă, ceea ce înseamnă că declară de câte ori este invocată o metodă. Semnătura metodei times() este:

 public static VerificationMode times(int wantedNumberOfInvocations) { return VerificationModeFactory.times(wantedNumberOfInvocations); } 

Metoda Mockito never().

Este folosit pentru a verifica dacă interacțiunea nu a avut loc. Semnătura metodei never() este:

funcții șir în java

 public static VerificationMode never() { return times(0); } 

Metoda Mockito atLeastOnce().

Este folosit pentru a verifica invocarea cel puțin o dată, ceea ce înseamnă că metoda trebuie invocată cel puțin o dată.

Semnătura metodei atLeastOnce() este:

 public static VerificationMode atLeastOnce() { return VerificationModeFactory.atLeastOnce(); } 

Metoda Mockito atLeast().

Este folosit pentru a verifica invocarea de cel puțin x de ori. De exemplu, dat atLeast(3) înseamnă că metoda va invoca de cel puțin trei ori.

Semnătura metodei atLeast() este:

 public static VerificationMode atLeast(int minNumberOfInvocations) { return VerificationModeFactory.atLeast(minNumberOfInvocations); } 

Metoda Mockito atMost().

Este folosit pentru a verifica invocarea de cel mult x de ori. De exemplu, dat atMost(3) înseamnă că metoda va invoca de maximum trei ori.

Semnătura metodei atMost() este:

 public static VerificationMode atMost(int maxNumberOfInvocations) { return VerificationModeFactory.atMost(maxNumberOfInvocations); } 

Metoda Mockito calls().

Permite o verificare non-lacomă în ordine. Poate fi folosit numai cu metoda de verificare inOrder(). De exemplu, inOrder.verify(mock, calls(3)).xyzMethod('...');

Semnătura metodei calls() este:

 public static VerificationMode calls( int wantedNumberOfInvocations ){ return VerificationModeFactory.calls( wantedNumberOfInvocations ); } 

Metoda Mockito only().

Verifică dacă metoda dată a fost singura metodă invocată. Semnătura metodei only() este:

eroare: nu s-a putut găsi sau încărca clasa principală

 public static VerificationMode only() { return VerificationModeFactory.only(); } 

Metoda Mockito timeout().

Permite lui Mockito să efectueze verificarea cu un timeout. Acesta indică unei verificări să aștepte o anumită perioadă de timp pentru o anumită interacțiune, mai degrabă decât să eșueze imediat. Poate fi util pentru testare în situații existente.

Metoda timeout() diferă de metoda after() deoarece metoda after() așteaptă întreaga perioadă decât dacă rezultatul final este declarat, în timp ce metoda timeout() se va opri imediat ce trece verificarea. Este rar folosit în testare.

Semnătura metodei timeout() este:

 public static VerificationWithTimeout timeout(long millis) { return new Timeout(millis, VerificationModeFactory.times(1)); } 

Metoda Mockito after().

Acesta permite lui Mockito să verifice într-o anumită perioadă de timp. Am discutat deja că metoda after() diferă de metoda timeout().

Semnătura metodei after() este:

 public static VerificationAfterDelay after(long millis) { return new After(millis, VerificationModeFactory.times(1)); } 

Metoda Mockito validateMockitoUsage().

Este folosit pentru validarea explicită a stării cadrului pentru a detecta utilizarea nevalidă a cadrului Mockito. Este o caracteristică opțională a Mockito, deoarece validează utilizarea tot timpul. Atât rulerul încorporat (MockitoJUnitRunner) cât și regula (MockitoRule) apelează metoda validateMockitoUsage() după fiecare metodă de testare.

Semnătura metodei validateMockitoUsage() este:

 public static void validateMockitoUsage() { MOCKITO_CORE.validateMockitoUsage(); } 

Mockito cu metoda Settings().

Este folosit pentru a crea imagini simulate cu setări suplimentare de simulare. Ar trebui folosit ocazional în testare. În loc să utilizați metoda withSettings(), creați teste simple folosind simulari simple. Principalele motive pentru utilizarea MockSettings sunt

• Utilizând MockSetting, putem adăuga cu ușurință alte setări simulate atunci când este necesar.
• Combină diferite setări simulate, fără a încurca codul.

Semnătura metodei withSettings() este:

 public static MockSettings withSettings() { return new MockSettingsImpl().defaultAnswer(RETURNS_DEFAULTS); }