A Mockito keretrendszer számos módszert kínál, például mock(), verify(), when() stb., amelyeket a Java alkalmazások tesztelésére használnak. Ezen előre meghatározott módszerek használata nagyon egyszerűvé teszi a tesztelést.

A Mockito módszerek rövid leírása az alábbiakban található:

java string formátum hosszú

Mockito mock() metódus

Egy adott osztály vagy interfész álobjektumainak létrehozására szolgál. A Mockito ötöt tartalmaz gúny() módszerek különböző érvekkel. Ha nem rendeltünk hozzá semmit a mockokhoz, akkor az alapértelmezett értékeket adják vissza. Mind az öt módszer ugyanazt a funkciót látja el, a tárgyak kigúnyolására.

Íme a mock() metódusok különböző paraméterekkel:

mock() metódus az osztállyal:Konkrét osztály vagy interfész álobjektumainak létrehozására szolgál. Paraméterként egy osztályt vagy egy interfésznevet vesz fel.
Szintaxis: gúny (Class classToMock)mock() metódus a válasszal:Egy osztály vagy interfész álobjektumainak létrehozására szolgál egy adott eljárással. Ez egy fejlett álmódszer, amely örökölt rendszerekkel való munkavégzés során használható. A Választ paraméterként veszi az osztály vagy interfész nevével együtt. A válasz az előre konfigurált álválaszok felsorolása.
Szintaxis: mock (Osztály osztály Mock, Válasz alapértelmezett Válasz)mock() metódus MockSettings-szel:Hamis objektumok létrehozására szolgál néhány nem szabványos beállítással. A MockSettings-t további beállítási paraméterként használja az osztály vagy interfész nevével együtt. A MockSettings lehetővé teszi álobjektumok létrehozását további beállításokkal.
Szintaxis: mock (Class classToMock, MockSettings mockSettings)mock() metódus ReturnValues ​​értékkel:Lehetővé teszi egy adott osztály vagy interfész álobjektumainak létrehozását. Mostanra elavult, mivel a ReturnValues ​​helyett az Answer szerepel.
Szintaxis: mock (Class classToMock, ReturnValues ​​returnValues)mock() metódus Stringgel:Hamisított objektumok létrehozására szolgál a hamis nevek megadásával. A hibakeresés során a hamis objektumok elnevezése hasznos lehet, míg a nagy és összetett kód használata rossz választás.
Szintaxis: mock(Osztály classToMock, Karakterlánc neve)

A következő kódrészlet bemutatja, hogyan kell használni gúny() módszer:

 ToDoService doService = mock(ToDoService.class); 

Mockito when() metódus

Lehetővé teszi a szúrási módszereket. Akkor kell használni, ha gúnyolódni akarunk, hogy adott értékeket adjunk vissza bizonyos metódusok meghívásakor. Egyszerűen, ' Amikor az XYZ() metódust hívják, akkor vissza az ABC-t.' Leginkább akkor használják, ha valamilyen feltétel van a végrehajtáshoz.

Szintaxis: when(T methodCall)

A következő kódrészlet bemutatja, hogyan kell használni a when() metódust:

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

A fenti kódban thenReturn() legtöbbször a amikor() módszer.

Mockito verify() metódus

A ellenőriz() metódus segítségével ellenőrizhető, hogy egyes megadott metódusok meghívásra kerülnek-e vagy sem. Egyszerűen fogalmazva, érvényesíti azt a bizonyos viselkedést, amely egy teszt során egyszer megtörtént. A tesztelési kód alján használatos annak biztosítására, hogy a meghatározott metódusok meghívásra kerüljenek.

A Mockito keretrendszer nyomon követi az összes metódushívást az objektumok gúnyolásához szükséges paramétereivel. A kigúnyolás után a verify() metódussal ellenőrizhetjük, hogy a meghatározott feltételek teljesülnek-e vagy sem. Ezt a fajta tesztelést néha úgy ismerik viselkedési tesztelés. Azt ellenőrzi, hogy egy metódust a megfelelő paraméterekkel hívják-e meg, ahelyett, hogy a metódushívás eredményét ellenőrizné.

A verify() metódus a hívások számának tesztelésére is szolgál. Így tesztelhetjük a meghívások pontos számát a segítségével alkalommal módszer, legalább egyszer módszer, és legfeljebb módszer egy kigúnyolt módszerért.

A Mockito osztályban kétféle verify() metódus áll rendelkezésre, amelyeket alább adunk meg:

verify() metódus:Ellenőrzi, hogy bizonyos viselkedés egyszer megtörtént.
Szintaxis: ellenőrizni (T gúny)verify() metódus a VerificationMode segítségével:Ellenőrzi, hogy bizonyos viselkedések legalább egyszer megtörténtek, pontosan hányszor vagy soha.
Szintaxis: ellenőrzés (T gúny, VerificationMode mód)

Mockito spy() metódus

A Mockito módszert biztosít egy objektum részleges gúnyolására, amely az úgynevezett kém módszer. A kémmódszer használatakor létezik egy valós objektum, és ebből a valódi objektumból kémek vagy csonkok jönnek létre. Ha nem csonkítunk el egy metódust a spy használatával, akkor a valódi metódus viselkedését fogja hívni. A spy() metódus fő funkciója, hogy felülírja a valós objektum specifikus metódusait. A spy() metódus egyik funkciója, hogy ellenőrzi egy bizonyos metódus meghívását.

A Mockito osztályban kétféle spy() metódus érhető el:

spy() metódus:Létrehozza a valódi tárgy kémjét. A spy metódus a valódi módszereket hívja meg, hacsak nem csonkolják őket. Óvatosan és alkalmanként használjuk az igazi kémeket, például amikor az örökölt kóddal foglalkozunk.
Szintaxis: kém (T objektum)spy() metódus a következő osztályokkal:Objektum helyett osztály alapján kémobjektumot hoz létre. A spy(T object) metódus különösen hasznos absztrakt osztályok kémkedésénél, mivel nem példányosíthatók.
Szintaxis: kém (Class classToSpy)

A következő kódrészlet a spy() metódus használatát mutatja be:

 List spyArrayList = spy(ArrayList.class); 

Mockito reset() metódus

A Mockito reset() metódus a mockok visszaállítására szolgál. Főleg a tartályba injektált gúnyokkal való munkához használják. Általában a reset() metódus hosszadalmas kódot és gyenge teszteket eredményez. A reset() metódus helyett jobb új mockeket létrehozni. Éppen ezért a reset() módszert ritkán használják a tesztelés során.

A reset() metódus aláírása a következő:

java objektum egyenlőség

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

Mockito verifyNoMoreInteractions() metódus

Annak ellenőrzésére szolgál, hogy az adott mockok bármelyike ​​rendelkezik-e ellenőrizetlen interakciókkal. Ezt a módszert használhatjuk az összes gúny ellenőrzése után, hogy megbizonyosodjunk arról, hogy semmi mást nem hívtak meg a gúnyokon. Érzékeli azokat az ellenőrizetlen hívásokat is, amelyek a tesztmetódus előtt fordulnak elő, például a setup(), a @Before metódusban vagy a konstruktorban. Ez egy opcionális módszer, és nem kell minden tesztben használnunk.

A verifyNoMoreInteractions() metódus aláírása a következő:

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

Mockito verifyZeroInteractions() metódus

Ellenőrzi, hogy nem történt-e interakció az adott mockeken. A tesztmetódus előtt történt meghívásokat is észleli, például a setup(), a @Before metódusban vagy a konstruktorban.

A verifyZeroInteractions() metódus aláírása a következő:

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

Mockito doThrow() metódus

Akkor használatos, amikor egy void metódust csonkítunk, hogy kivételt dobjunk. Minden metódushíváshoz új kivételpéldányt hoz létre. Kétféle doThrow() metódus érhető el a Mockito osztályban különböző paraméterekkel, az alábbiak szerint:

doThrow() metódus Throwable-val:Ezt a módszert akkor használjuk, ha egy érvénytelen metódust akarunk csonkítani egy kivétellel. Szintaxis: doThrow (dobható dobás)
A doThrow() metódus aláírása a következő:

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

doThrow() metódus osztállyal:Ezt a metódust akkor használjuk, ha egy void metódust akarunk csonkolni, hogy kivételt dobjunk egy adott osztályból.
Szintaxis: doThrow (Dobbantandó osztály)
A doThrow() metódus aláírása a következő:

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

Mockito doCallRealMethod() metódus

Akkor használjuk, ha egy metódus valós megvalósítását akarjuk meghívni. Más szavakkal, egy objektum részleges gúnyának létrehozására szolgál. Ritka helyzetekben használják, mint például a valódi módszerek elhívására. Hasonló a spy() metódushoz, és az egyetlen különbség az, hogy összetett kódot eredményez.

A doCallRealMethod() metódus aláírása a következő:

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

Mockito doAnswer() metódus

Akkor használjuk, ha egy void metódust akarunk lecsonkítani egy általános választípussal. A doAnswer() metódus aláírása a következő:

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

Mockito doNothing() metódus

A void metódusok semmittevésre való beállítására szolgál. A doNothing() metódus ritka esetekben használatos. Alapértelmezés szerint az álpéldányokon a void metódusok nem csinálnak semmit, azaz nem hajtanak végre feladatot.

A doNothing() metódus aláírása a következő:

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

Mockito doReturn() metódus

Azokban a ritka esetekben használatos, amikor nem tudjuk használni a Mockito.when(object) függvényt. A Mockito.when(object) metódus mindig javasolt a stubinghoz, mert argumentumtípus-biztonságos és jobban olvasható a doReturn() metódushoz képest.

A doReturn() metódus aláírása a következő:

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

Mockito inOrder() metódus

Olyan objektumok létrehozására szolgál, amelyek lehetővé teszik a gúnyok meghatározott sorrendben történő ellenőrzését. A sorrendben végzett ellenőrzés rugalmasabb, mivel nem kell minden interakciót ellenőriznünk. Csak a tesztelésben érdekelt interakciókat kell ellenőriznünk (sorrendben). Az inOrder() metódussal létrehozhatunk egy inOrder objektumot is, amely a rendelésen belüli ellenőrzés szempontjából releváns gúnyokat továbbít.

A Mockito.inOrder() metódus aláírása a következő:

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

Mockito ignoreStubs() metódust

Arra használják, hogy figyelmen kívül hagyják az adott gúnyok ellenőrzési módszereit. Hasznos a verifyNoMoreInteractions() vagy a verification inOrder() metódusokkal. Segít elkerülni az elakadt hívások redundáns ellenőrzését is.

Az ignoreStubs() metódus aláírása a következő:

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

Mockito times() metódus

A metódushívások pontos számának ellenőrzésére szolgál, ami azt jelenti, hogy deklarálja, hogy egy metódust hányszor hívják meg. A times() metódus aláírása:

java helyettesítés

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

Mockito never() metódus

Ez annak ellenőrzésére szolgál, hogy az interakció nem történt-e meg. A never() metódus aláírása:

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

Mockito atLeastOnce() metódus

A hívás legalább egyszeri ellenőrzésére szolgál, ami azt jelenti, hogy a metódust legalább egyszer meg kell hívni.

Az atLeastOnce() metódus aláírása a következő:

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

Mockito atLeast() metódus

A meghívás legalább x-szeres ellenőrzésére szolgál. Például az adott atLeast(3) azt jelenti, hogy a metódus legalább háromszor fog meghívni.

Az atLeast() metódus aláírása a következő:

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

Mockito atMost() metódus

Legfeljebb x számú alkalommal használható a hívás ellenőrzésére. Például az adott atMost(3) azt jelenti, hogy a metódus legfeljebb háromszor fog meghívni.

Az atMost() metódus aláírása:

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

Mockito meghívja() metódust

Lehetővé teszi a nem mohó ellenőrzést sorrendben. Csak az inOrder() ellenőrzési módszerrel használható. Például: inOrder.verify(mock, calls(3)).xyzMethod('...');

A calls() metódus aláírása a következő:

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

Csak Mockito() metódus

Ellenőrzi, hogy az adott metódus volt-e az egyetlen meghívott metódus. Az only() metódus aláírása:

git állapot

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

Mockito timeout() metódus

Lehetővé teszi a Mockito számára, hogy időtúllépéssel végezzen ellenőrzést. Arra utasítja az ellenőrzést, hogy várjon egy adott ideig egy adott interakcióra, nehogy azonnal meghiúsuljon. Hasznos lehet meglévő helyzetekben történő teszteléshez.

A timeout() metódus eltér az after() metódustól, mivel az after() metódus a teljes időtartamig vár, hacsak nem deklarálják a végeredményt, míg a timeout() metódus leáll, amint az ellenőrzés sikeres. Ritkán használják teszteknél.

Az timeout() metódus aláírása a következő:

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

Mockito after() metódus

Lehetővé teszi a Mockito számára, hogy egy adott időtartam alatt ellenőrizze. Korábban már tárgyaltuk, hogy az after() metódus eltér a timeout() metódustól.

Az after() metódus aláírása:

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

Mockito validateMockitoUsage() metódus

A keretállapot explicit érvényesítésére szolgál a Mockito keretrendszer érvénytelen használatának észlelésére. Ez a Mockito opcionális funkciója, mert folyamatosan ellenőrzi a használatot. A beépített futtató (MockitoJUnitRunner) és a szabály (MockitoRule) is meghívja a validateMockitoUsage() metódust minden tesztmetódus után.

A validateMockitoUsage() metódus aláírása a következő:

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

Mockito withSettings() metódussal

Gúnyok létrehozására szolgál további álbeállításokkal. Alkalmanként kell használni a tesztelés során. A withSettings() metódus helyett egyszerű teszteket készítsen egyszerű mockok segítségével. A MockSettings használatának fő okai a következők

• A MockSetting használatával szükség esetén könnyen hozzáadhatunk más álbeállításokat.
• Különböző álbeállításokat kombinál a kód elrontása nélkül.

A withSettings() metódus aláírása a következő:

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