streamalism.org

1. Áttekintés

Ebben az oktatóanyagban megnézzük a MockK könyvtár néhány alapvető tulajdonságát.

2. GúnyK

Kotlinban minden osztály és módszer végleges. Bár ez segít megváltoztathatatlan kód megírásában, a tesztelés során némi problémát is okoz.

A legtöbb JVM gúnykönyvtárnak problémái vannak a végső osztályok gúnyolódásával vagy elcsépelésével. Természetesen hozzáadhatjuk anyisd ki”Kulcsszó azokhoz az osztályokhoz és módszerekhez, amelyeket meg akarunk csúfolni. De az osztályok megváltoztatása csak bizonyos kódok kigúnyolása érdekében nem a legjobb megoldás.

Itt jön a MockK könyvtár, amely támogatást nyújt a Kotlin nyelvi jellemzőihez és konstrukcióihoz. A MockK proxykat épít a csúfolt osztályok számára. Ez némi teljesítményromlást okoz, de a MockK által nyújtott általános előnyök megéri.

3. Telepítés

A telepítés a lehető legegyszerűbb. Csak hozzá kell adnunk a mockk függőséget a Maven projektünkhöz:

 io.mockk mockk 1.9.3 teszt 

A Gradle esetében hozzá kell adnunk tesztfüggőségként:

testImplementation "io.mockk: mockk: 1.9.3"

4. Alap példa

Hozzunk létre egy szolgáltatást, amelyet csúfolni szeretnénk:

osztály TestableService {fun getDataFromDb (testParameter: String): Karakterlánc {// lekérdezés adatbázisa és visszatérési érték}} fun doSomethingElse (testParameter: String): String {return "Nem akarom!" }}

Itt egy példa teszt, amely gúnyolódik TestableService:

@Test fun givenServiceMock_whenCallingMockedMethod_thenCorrectlyVerified () {// megadott val service = mockk () minden {service.getDataFromDb ("Várható paraméter")} "Várható kimenet" eredményt ad // amikor val eredmény = service.getDataFromDb ("Várható paraméter") // majd ellenőrizze a {service.getDataFromDb ("Várható paraméter")} assertEquals ("Várható kimenet", eredmény)}

Az álobjektum meghatározásához a gúny () módszer.

A következő lépésben meghatároztuk a gúnyunk viselkedését. Erre a célra létrehoztunk egy minden blokk, amely leírja, hogy melyik hívásra milyen választ kell adni.

Végül a igazolja blokkolja annak ellenőrzésére, hogy az álra hivatkoztak-e, mint vártuk.

5. Annotációs példa

Lehetőség van a MockK annotációk használatára mindenféle gúnyok létrehozására. Hozzunk létre egy olyan szolgáltatást, amely két példányt igényel TestableService:

class InjectTestService {lateinit var service1: TestableService lateinit var service2: TestableService fun invokeService1 (): String {return service1.getDataFromDb ("Test Param")}}

InjectTestService két azonos típusú mezőt tartalmaz. Nem lesz gond a MockK számára. A MockK megpróbálja a tulajdonságokat név szerint, majd osztály vagy szuperosztály szerint egyeztetni. Az is nem okoz problémát a tárgyak magánterületekbe történő befecskendezésével.

Gúnyolódjunk InjectTestService egy tesztben kommentárok használatával:

class AnnotationMockKUnitTest {@MockK lateinit var service1: TestableService @MockK lateinit var service2: TestableService @InjectMockKs var objectUnderTest = InjectTestService () @BeforeEach fun setUp () = MockKAnnotations.init (this) // Tests here ... this

A fenti példában a @InjectMockKs annotáció. Ez egy olyan objektumot határoz meg, amelybe meghatározott gúnyokat kell beadni. Alapértelmezés szerint olyan változókat injektál, amelyek még nincsenek hozzárendelve. Tudjuk használni @OrrideMockKs hogy felülbírálja azokat a mezőket, amelyeknek már van értéke.

A MockK megköveteli MockKAnnotations.init (…) hogy egy változót annotációkkal deklaráló objektumra kell meghívni. A Junit5 esetében ez helyettesíthető @ExtendWith (MockKExtension :: osztály).

6. Kém

A kém lehetővé teszi, hogy valamilyen osztálynak csak egy adott részét csúfolják. Például fel lehet használni egy adott módszer megcsúfolására a TestableService:

@Test fun givenServiceSpy_whenMockingOnlyOneMethod_thenOtherMethodsShouldBehaveAsOriginalObject () {// megadott val service = spyk () minden {service.getDataFromDb (any ())} "Mocked Output" eredményt ad vissza, ha ellenőrzi a gúnyolt metódus szolgáltatását. // majd assertEquals ("Kigúnyolt kimenet", firstResult) // a nem kigúnyolt módszer ellenőrzésekor val secondResult = service.doSomethingElse ("Bármelyik paraméter") // majd assertEquals ("Nem akarom!", secondResult)}

A példában a spyk módszer kémobjektum létrehozására. Használhatnánk a @SpyK jelölés ugyanezért:

class SpyKUnitTest {@SpyK lateinit var service: TestableService // Tesztek itt}

7. Nyugodt gúny

Egy tipikus csúfolt tárgy dob MockKException ha megpróbálunk olyan metódust hívni, ahol a visszatérési érték nincs megadva.

Ha nem akarjuk leírni az egyes módszerek viselkedését, használhatunk nyugodt gúnyt. Ez a fajta modell minden funkcióhoz alapértelmezett értékeket ad. Például a Húr A return type egy üreset ad vissza Húr. Itt egy rövid példa:

@Test fun givenRelaxedMock_whenCallingNotMockedMethod_thenReturnDefaultValue () {// megadott val service = mockk (relaxed = true) // amikor val result = service.getDataFromDb ("Bármelyik paraméter") // majd assertEquals ("", eredmény)}

A példában a gúny módszer a kipihent attribútumot egy nyugodt mock objektum létrehozásához. Használhatnánk a @RelaxedMockK kommentár:

class RelaxedMockKUnitTest {@RelaxedMockK lateinit var service: TestableService // Tesztek itt}

8. Tárgygúny

Kotlin egyszerű módot kínál a szingulett kinyilvánítására a tárgy kulcsszó:

objektum TestableService {fun getDataFromDb (testParameter: String): Karakterlánc {// lekérdezési adatbázis és egyező érték visszaadása}}

A legtöbb gúnyos könyvtárnak azonban problémája van a Kotlin-féle egyedi példányok kigúnyolásával. Emiatt a MockK biztosítja a mockkObject módszer. Lássuk:

@Test fun givenObject_whenMockingIt_thenMockedMethodShouldReturnProperValue () {// megadott mockkObject (TestableService) // nem kigúnyolt metódus hívásakor val firstResult = service.getDataFromDb ("Bármelyik paraméter") // majd visszaadja a valódi választ firstert AssertEquals / // amikor a csúfolt metódust meghívja, minden {service.getDataFromDb (any ())}} visszaadja a "Gúnyolt kimenetet" val secondResult = service.getDataFromDb ("Bármelyik paraméter") // majd visszaküldi a csúfolt választ assertEquals ("Kigúnyolt kimenet", secondResult)}

9. Hierarchikus gúny

A MockK másik hasznos tulajdonsága a hierarchikus objektumok kigúnyolásának képessége. Először hozzunk létre egy hierarchikus objektumstruktúrát:

class Foo {lateinit var név: String lateinit var bar: Bár} class Bar {lateinit var becenév: String}

A Foo osztály tartalmaz egy típusú mezőt Rúd. Most csak egy egyszerű lépésben gúnyolhatjuk a szerkezetet. Gúnyolódjunk a név és becenév mezők:

@Test fun givenHierarchicalClass_whenMockingIt_thenReturnProperValue () {// adott val foo = mockk {minden {név} "Karol" -ot ad vissza, minden {bar} visszaadja a mockkot {minden {becenév} "paradicsomot"}}} //, amikor val név = foo.name val becenév = foo.bar.nickname // majd assertEquals ("Karol", név) assertEquals ("Paradicsom", becenév)}

10. Paraméterek rögzítése

Ha meg kell ragadnunk a metódusnak átadott paramétereket, akkor használhatjuk CapturingSlot vagy MutableList. Akkor hasznos, ha valamilyen egyéni logikát akarunk használni az válasz blokkolja, vagy csak ellenőriznünk kell az átadott argumentumok értékét. Itt van egy példa CapturingSlot:

@Test fun givenMock_whenCapturingParamValue_thenProperValueShouldBeCaptured () {// megadott val service = mockk () val slot = slot () minden {service.getDataFromDb (capture (slot))} eredményt a "Várható kimenet" // adja vissza, amikor service.getDataFromDb ("Várható paraméter" ) // majd assertEquals ("Várható paraméter", slot.captured)}

MutableList használható az összes metódus meghívás specifikus argumentumértékeinek rögzítésére és tárolására:

@Test fun givenMock_whenCapturingParamsValues_thenProperValuesShouldBeCaptured () {// megadott val service = mockk () val list = mutableListOf () minden {service.getDataFromDb (capture (list))}} "Várható kimenetet" eredményez // amikor service.getDataFromDb ") service.getDataFromDb (" Várható 2. paraméter ") // majd assertEquals (2, list.size) assertEquals (" Várható paraméter 1 ", lista [0]) assertEquals (" Várható 2. paraméter ", lista [1])}

11. Következtetés

Ebben a cikkben megvitattuk a MockK legfontosabb jellemzőit. A MockK egy hatékony könyvtár a Kotlin nyelv számára, és rengeteg hasznos funkcióval rendelkezik. További információk a MockK-ról a MockK webhelyén található dokumentációban találhatók.

Mint mindig, a bemutatott mintakód felülről elérhető a GitHubon.