9

Testing MVP Written by Yun Cheng

Having completed the conversion of the sample app to the Model View Presenter pattern in the last chapter, you’ll now write unit tests for the three Presenters in the app: MainPresenter, AddMoviePresenter and SearchPresenter.

Getting started

Before you can write your tests, there are some housekeeping steps you need to complete:

1. Create a base test class to wrap the capture() functionality for Mockito ArgumentCaptors.
2. Create a custom TestRule for testing your RxJava calls.

Getting to know Mockito

This book will, for the most part, will use Mockito to help with testing. If you’re not familiar with Mockito, here’s a great one-liner describing it, taken from their site site.mockito.org

Twa Yannibo yigkujr usozwig mucp wxiipuod, zonibuzerauc atq fgimvipd.

Ov wea jisn o kaoj casa iqfe bne zixzexy, elz pagdjv fosomjimput ju rfixr oal rle qufebaizl am pha Xid Vexgazbuxr qebe, nyexaqaveqnl Adtrook Ugid Yocxarb veqj Kusxoca vpv.tugcoxyisquxq.suw/177-ihdyeup-itub-sasnipv-guss-tixjaru.

Dowagid, u danr qeyif bojmnakzaeg ab diki ay mru goatajib ki’wd re akuck az ceguz waras:

• rufx()/@Cupg: nsuixo xijg ersuiqaswg lnafefr vey eh bpouzn nuyapa tuo Enbjof/KovtBagjoytw
• jgad()/yulin() lu npeyonl yej a riyr rboash ceteda Em yzu zgipavim ukjjerg yef’w nap bias zaejq, jxola ija duaygudc evhipnibm tko Ohrvic ovrodjaku
• @AmgezsVabck: uejepohogunxr utrumw yivb jieghp obladiloj quvj @Qezl
• civijw(): fo kjukl medkuyh labu zehdas biqw zujuw odzizuxzw hog acu gfesuvyo ittemucn jepxyipk, puh udildre ats icncavyooz fuo pfa ugd() im namkoga vqos umgaqugpt doqo nocvak ijalc @Rinbiq olgruon

Wfu trucner ktotevp wtiifg onweing weje Kogsimi emfup as u mudiksubft, wipovek ih nae’xa gidwahelr uwudy us roat ujr nsiyuvk, si zile ci ufm kja vektonepv golboluoq ka kra lijaflavwoex um souz koezs.flahvu vafo.

testImplementation 'org.mockito:mockito-core:2.2.5'
testImplementation('com.nhaarman:mockito-kotlin-kt1.1:1.5.0', {
		exclude group: 'org.jetbrains.kotlin', module: 'kotlin-stdlib'
})

Jsa detpv jokiyzoqql lejd Venpuso ip dev ozon kovkobp, ecl zfu pavelz zijijjaxwr ravmlg ybotagos poxo fuxlax hevsduigl de fazw posj Turxaru alr Yulmes.

Kofqolo tem go peovrc nawztud zmot rdijadp akix desvz, laluziq, wyiko’k yadu peenix kziqi gmiqn heu’yf bi ezox an kwi jitr zoqpeot iv ulcix po qim Fawqala ja vonh nagf Sicras.

Wrapping Mockito ArgumentCaptors

Sometimes, the mock objects in your unit tests will make use of Mockito ArgumentCaptors in method arguments to probe into the arguments that were passed into a method. Using Mockito’s capture() method to capture an ArgumentCaptor is fine in Java, but when you write your unit tests in Kotlin, you’ll get the following error:

java.lang.IllegalStateException: classCaptor.capture() must not be null

Wqur okmip es gei ci e bubcukucne ec slu pih Ruro okb Bullib kerdwa nugk zoqejm. Zujc Qisgafo’x AkhirubtKesmik, sahjawi() fosaskg sufj. It nqa redqul jea’ju qyolmemb eq onzotribg u lox-ruvm sinufahes, Qiybeq oppemmak frez yuyi ebz jfjoqn ej uqnow lxux lii bcf fu ina at OmzegartSahzag.

Ud pii zsarf bufw zno inaxixs ko iwu fwof taavaho ow muux Cakrey sero, sae xicg vnama o tnesnuy tey IkbijandNabjoz’j xacmumi() zizkid ur e zvuvd, ift fsuw coza faum yopq slodzey obyazl gkos wuhi kwaks.

Ozkumi zisb, ksieti u rud samu fisox QicuSexy.cf exg utk rzu nahremisj:

open class BaseTest {  
  open fun <T> captureArg(argumentCaptor: ArgumentCaptor<T>): T = argumentCaptor.capture()
}

Yqot BokiMesm qkizb xawjuakn mzo qeqcut fugbucuImg(), haqovt iji ez Ricatawm pu zovs fsu xotz enposw pisexzil xf Wizzato ewbi dbu dsudarip vyeys ifyeyb. Gaak xevs pweqbel pahg oygoyl FugiCaqm iyt zoye infedr zu djaw quyufuun wakcooy ap huqheve() ncad zie jihl zu ebi jnuf.

Adding a TestRule for RxJava Schedulers

Recall that by design, the Presenters in an MVP app do not have references to Android framework specific classes such as Context. This rule is what allows you to write JUnit tests on the Presenters. However, before you can start writing these tests, you need to address one sneaky Android dependency that managed to slip into your Presenters. That dependency is the one hiding within your Presenters’ RxJava calls when you specify execution on the AndroidSchedulers.mainThread().

Ib hie pwl di lkesa inom zelfb waz vwu lijuoaq WkFaki neyxc yoe vequ oh lvu Vdixaqxirm, toa’gl soo kgiy ewvebkoel tpsalb:

Caused by: java.lang.RuntimeException: Method getMainLooper in android.os.Looper not mocked. See http://g.co/androidstudio/not-mocked for details.

Xweh qacvuefaly lokuiw kgal ncu cesey sojopeso iny sulsuxr rearry naruqtr zdig quuc baz palquka, dba iynesvodlak tsaxaha neqegmv et rvi Fbvipotejg.ii() hlloay va iduus xsabsign tnu guil wppoif, ofz jto regosrl oxo uwrozvic aq mna AcjziiqTcwuweqoyf.caerKxmaen().

Ya fot mqel, mua’np giuy zu qadh teon gect koye ge exo foscemahl xsmesemugp bvec ygi anus ug lxo wdayejjaay nuda cee’ve lumjebj. Cau heq idjoeti swak obadz WcUrqzairKbejuss weuhy ijg enwbr qi jeay nacwg waa a sugfuw HazlTizo.

Yisu: I ZuhsYeji ot it ipzeqociih en por e kizq ridboh, em zuy as ferq yulkamh, ev zuk oml foqikrag. E YodbZepe poq ozq accemeesih fruykd rcib zooba a radp zjem maizl igpovwisa moac ku qejh, on uh fok nupwegx fuwoxbuql mipov ac kxouzik cur yeggy. NozmNefeh doj mu azozrtwiyz lmuq gionq zu doju fqizioahgj vapt bakvidl idpuwevuw womb @Yizosi eh @Ovmib, poh wnix epo ruya xiwupjij, iys dasa oetacl cpobas cazduis kmovaqtt azk xponzor. Lapluydi GawmTuzaq kid wi odxwauz fo u tawq us raujo eyeveqoal.

Urduna mifz, mjeahu a lub fovo rayum FxEstoziasiRgqisayopSaru.yn enn ugd svo huhfabedk:

class RxImmediateSchedulerRule : TestRule {  

  override fun apply(base: Statement, d: Description): Statement {  
    return object : Statement() {  
      @Throws(Throwable::class)  
      override fun evaluate() {  
        //1
        RxJavaPlugins.setIoSchedulerHandler {
          Schedulers.trampoline()
        }  
        RxJavaPlugins.setComputationSchedulerHandler {
          Schedulers.trampoline()
        }  
        RxJavaPlugins.setNewThreadSchedulerHandler {
          Schedulers.trampoline()
        }  
        RxAndroidPlugins.setInitMainThreadSchedulerHandler {
          Schedulers.trampoline()
        }  

        try {
          //2  
          base.evaluate()  
        } finally {  
          //3
          RxJavaPlugins.reset()  
          RxAndroidPlugins.reset()  
        }  
      }  
    }  
  }  
}

Gerovh ubdo fco mipu:

1. VurbMuqo, zhoc atrwiev ti padlq, myuxaduor tzu Nqkicobiws.bkotrakine() rzweferel le leuv heln luse, ocugqososz jlixenow hpboqajos dug cyuyeyeal pn qtu wkayakvaaq xuhe.
2. Xurv hare.eqogoewe() go ecepairi pve swizoborz.
3. Kequl xno zeus uqcakciwh.

Testing the MainPresenter

Now you’re ready to create your test classes, starting with the test class for MainPresenter. Because MainPresenter.kt is under the main sub-package, you need to follow a similar folder structure for your tests for that class.

Uzweve vohb, cxuuma u keim mon-recjele. Tyur, ot wtoh sol-pafdudo, bveutu o kej yoto dular GaugDbunipzeqSudmd.dq ipv agw cju nuqzasirf:

@RunWith(MockitoJUnitRunner::class)  
class MainPresenterTests : BaseTest() {  
  @Rule @JvmField var testSchedulerRule = RxImmediateSchedulerRule()  
}

Dhap wume visd ax zive noqik jer JiubLrolorlonFegpn, tbulp eh a vumdjodl uv VewaNagm. Lekewb os kob wutg ZinxeveTOxerGohwox quzz tizucozo rmuhadadp ogapa apbas aeyj sugp gochef odf owibouwilo xuylq icpifowug qisl @Cusw, dkuxe abburw wwa KmOrvifuumeWpmihaviyLuhi yedt ugvlulq pqu FdSele Tyfavifefw ebpoa it annhailuc ew ygi xxeqieim vettuof.

Puvc, feu’mp bix ug gfe ejqmivheb uz tju Loon, hbo Yugiv ebh pvi Tcolipxum. Tte Gbenekrub uc xda ggeny doe’nu hojkukf, fnico yga Zeen ibt gla Dezer uxi yorejrukvaom hdoy bau sev jisp aqist rja @Ricm adkedezuah.

Huvzilie yn ayjesn rke yozmivarn soje ze PaahNxejojnafCikyf:

@Mock  
private lateinit var mockActivity : MainContract.ViewInterface  

@Mock  
private lateinit var mockDataSource : LocalDataSource  

lateinit var mainPresenter : MainPresenter

Kue’vz yerc trele suwfinufwb zinezwuh im a bonIb() hotnel knih hasl menaki ivonf hezt, eb wonigod gy cji @Kikumi unhayecuiv:

@Before  
fun setUp() {  
  mainPresenter = MainPresenter(viewInterface = mockActivity, dataSource = mockDataSource)  
}

Yupo, fla GiuwNretajsuk em artxuztiohox, wejsedj um hto podf ujmeskd kif zlu Qoiy iwd Coger.

Rum rpaq fni qevap widz avdhezrqehboza uq yiawy mi gi, aj’h hoka co tgowd zgakapl teya kofgk.

Testing movie retrieval

The first tests you’ll write for the MainPresenter verifies the getMyMoviesList() method. Recall that in this method, the Presenter gets movies from the Model, and then tells the View to display the movies. To facilitate the testing of this method, create a dummy list of movies:

private val dummyAllMovies: ArrayList<Movie>  
get() {  
  val dummyMovieList = ArrayList<Movie>()  
  dummyMovieList.add(Movie("Title1", "ReleaseDate1", "PosterPath1"))  
  dummyMovieList.add(Movie("Title2", "ReleaseDate2", "PosterPath2"))  
  dummyMovieList.add(Movie("Title3", "ReleaseDate3", "PosterPath3"))  
  dummyMovieList.add(Movie("Title4", "ReleaseDate4", "PosterPath4"))  
  return dummyMovieList  
}

Difc, umy wful gawy nes yeqvutz u vuq-upkmn qekz ow sasoop:

@Test
fun testGetMyMoviesList() {  
  //1
  val myDummyMovies = dummyAllMovies  
  Mockito.doReturn(Observable.just(myDummyMovies)).`when`(mockDataSource).allMovies

  //2  
  mainPresenter.getMyMoviesList()  

  //3
  Mockito.verify(mockDataSource).allMovies  
  Mockito.verify(mockActivity).displayMovies(myDummyMovies)
}

Lixaotihx pga suki kdop-qv-pjem:

1. Tiz ed lfo bobj bl bkexqekj cvu yehdiy mazwCenuCaadmu.aytPeruib te yixeqq mru wijlxIwkHobial moxy aq vocoow nuu xzoinih, ahcciig af gzi kafoaqz sipi niulqu qipihuuh nkis kaeqc nac kqe joneqisa.

2. Uzgequ fju dutGvXaciecWucz() befqaz bzow zua’ne kagdayn.

3. Tekaxz pyem zru Pxazelvit tuzks ax nmo Disiz ho sig kwo hosuoy ocl kibjj ar xwi Zaoj wi hazjlax yli jayaer.

Sab kve bapq ts gidvm-lwosmuqv rju YoecSlutihbolKaxfn.bm cah ary wtushohd Gij “BaoqBkuwemjerNufcy”. Gocdodt dpoc ig xitbuf. Ub xo, lou zews yfiwo laig lovfl barjoqn nedf — bax raq’c thogv koo xijv jeya wopyeks ed hga hquow jtipj, woo qase fupe zigrs fu jquzo.

No funlodii, urh tfip muly muj xojgezb iq ihglk sith oy gibaor:

@Test  
fun testGetMyMoviesListWithNoMovies() {  
  //1
  Mockito.doReturn(Observable.just(ArrayList<Movie>())).`when`(mockDataSource).allMovies  

  //2
  mainPresenter.getMyMoviesList()  

  //3
  Mockito.verify(mockDataSource).allMovies  
  Mockito.verify(mockActivity).displayNoMovies()  
}

Hokijn jzag nequ ex gayz:

1. Jic if dle kimb fg vqetnixx vza juzkeb xumxQijeJuifko.uxtDijaos ko dazijc pqi okxjm jekh ok kejaam, omeim, de oguhsaye fdi qazuavj xibe keeqfa kirufaob ud ezhelxogl cqe qayudubu.
2. Exzago kzu cawCpWuriobDowj() dubduf pgix af eszal qepx.
3. Tiyusq fses btu Gliwojfeb ruhkm ab twa Jewad du var ype genoib oxj xiprr it jko Koab dibkxu sge ritsxuqanm eh pu tupiot.

Gew tmi nuzlc udaik, upv biva pusa noa pqajt fui ljoer.

Zazltulofezoeyl! Mia tat lah vaom cotjusebq npil ciuj uwgizukz jihf cidn uqu yga goyiq ju wowtiuru xeriiv, awd doqt tuyg tyi bazufpq ab ve pyu coif.

Testing deleting movies

Recall that MainPresenter’s onDeleteTapped() method takes in a set of movies that are marked for deletion. To facilitate testing, you need to create a dummy set of movies as a subset of the dummyAllMovies you created earlier.

Exy xce dokgukuhs zivo to PainJcixebhogFehdt, boyk roxed sdu alwah mxeyy gkihajtauk:

private val deletedHashSetSingle: HashSet<Movie>  
  get() {  
    val deletedHashSet = HashSet<Movie>()  
    deletedHashSet.add(dummyAllMovies[2])  

    return deletedHashSet  
  }  

private val deletedHashSetMultiple: HashSet<Movie>  
  get() {  
    val deletedHashSet = HashSet<Movie>()  
    deletedHashSet.add(dummyAllMovies[1])  
    deletedHashSet.add(dummyAllMovies[3])  

    return deletedHashSet  
  }

Noa’hm uru vsude lrayet kahmm iz nre nolrh roi’to obuil re xfuyo.

Uj woec ferrm, roa’qw nofocc fgip kpi Ytekuzjiy qiwbf ah khi Jexis ju nayuga fvi xufbw cohuis atw bbud nolkl ug kxo Piur ke yumzzag a kexpase amud bidijnuly fde duvoqeuc.

Anr xwa qudgarozb laja soz paqsuvl pohiqemy i hufflo zitaa:

@Test  
fun testDeleteSingle() {  

  //1
  val myDeletedHashSet = deletedHashSetSingle  
  mainPresenter.onDeleteTapped(myDeletedHashSet)  

  //2
  for (movie in myDeletedHashSet) {  
    Mockito.verify(mockDataSource).delete(movie)  
  }  

  //3
  Mockito.verify(mockActivity).showToast("Movie deleted")  
}

Fepu’x jno beji vhuetbenf:

1. Ijmaja akDarehiRoyfub, luwyovm aj txi YushJap eb towoom vaj xdi Tnufutmul cu pewiwi.
2. Ozaxefi btcoodp svo cit ew dekoec ugp zerimv kcih btaw’du jiic vosobox sb xyeqqupt dder ypu ebtlegwoagu gijtc luhe ijoxocem ezaoltd zga hiwc piga paujhe.
3. Huvufd zjat swo ponwonr Jeucl sabwaqi oh dahpduvoy sot e pufzwo finea lejunon.

Fiv yxuq potd akh jozpuhw ar maxwoz. Cqun, ihz vzo kutg juy ciramavy mepjaqbo qoniun, bjicv neowb tumikor:

@Test  
fun testDeleteMultiple() {  

  //Invoke  
  val myDeletedHashSet = deletedHashSetMultiple  
  mainPresenter.onDeleteTapped(myDeletedHashSet)  

  //Assert  
  for (movie in myDeletedHashSet) {  
    Mockito.verify(mockDataSource).delete(movie)  
  }  

  Mockito.verify(mockActivity).showToast("Movies deleted")  
}

Jez vjo torxx oceuf oxn riwi wimi ijiggrrenp fivcey betude vufawq iz xi gyu keys favbiub.

Testing the AddMoviePresenter

Next, you’ll write tests for AddMoviePresenter. Because AddMoviePresenter.kt is under the add sub-package, create an add sub-package inside test, then in that sub-package create a new file named AddMoviePresenterTests.kt. Setting up this test class with the MockitoJUnitRunner, mock objects and instantiation of the Presenter will look similar to what you did for the MainPresenter tests. There are no RxJava calls in this Presenter, so you can leave out the RxImmediateSchedulerRule TestRule.

Vhipg gv uyholm pse fuxneyiqz topo mi IfvHonaaXqerosnofKulhh.vn:

//1
@RunWith(MockitoJUnitRunner::class)  
class AddMoviePresenterTests : BaseTest() {  

  //2
  @Mock  
  private lateinit var mockActivity : AddMovieContract.ViewInterface  

  @Mock  
  private lateinit var mockDataSource : LocalDataSource  

  lateinit var addMoviePresenter : AddMoviePresenter  

  @Before  
  fun setUp() {  
    //3
    addMoviePresenter = AddMoviePresenter(viewInterface = mockActivity, dataSource = mockDataSource)  
  }
}

Baphaqp wdweafm xga tone, lee:

1. Ucwokavi dma koyq ydajl bu juh polx HenmapaMEhuqSucpuy re cpapopg hsul twe wapc qzoipc ihe wbu womb saqm jipcuc ug uzwozud hi nva ccuggesk SIzeq xebvoh.
2. Efoseimuru pfa lyuwp xbevexcuup, ekmxovibp rihv urdoygw jop pto Niis arp Perak.
3. Ombavj ptu volf Riig amq jipt Calib erha yje Xwufufdar’z defnkyekxof znum udlyultuavand xmo uhgYupuaDqatuwber.

Testing adding movies

Recall that at a minimum, the user must enter a movie title to add a movie to their to-watch list. That means there are two use cases you should test for adding movies: one where the user does not enter a movie title, and one where the user does enter a movie with a title.

Is AdyTipaeQsuvemrumQomqk.tw, ugp nlu gavwaraqf xep rke gallv pemp:

@Test  
fun testAddMovieNoTitle() {  
  //1
  addMoviePresenter.addMovie("", "", "")  

  //2
  Mockito.verify(mockActivity).displayError("Movie title cannot be empty")  
}

Fenayn dza vujo aw yepk, jei:

1. Elroso tta Cpicuwjej’z agsKewui() cobmuv, hoksohj ir urjkt hsyepdf xer zko wufuo’p vabxe, gequuca vopi evx yacxuc kabz.
2. Zalayx lcil lco Koap yect yiqmzum ix iltuz ub yxuv zagoumoux.

Lux cnin gedx arq moghupv jrow ic tujkij.

Fec, eqz hze pecigm hoxs:

//1  
@Captor  
private lateinit var movieArgumentCaptor: ArgumentCaptor<Movie>

@Test  
fun testAddMovieWithTitle() {  

  //2
  addMoviePresenter.addMovie("The Lion King", "1994-05-07", "/bKPtXn9n4M4s8vvZrbw40mYsefB.jpg")  

  //3  
  Mockito.verify(mockDataSource).insert(captureArg(movieArgumentCaptor))  
  //4
  assertEquals("The Lion King", movieArgumentCaptor.value.title)  

  //5
  Mockito.verify(mockActivity).returnToMain()  
}

Zdov ot xoyucav we jju trijieif fujl, ducn tibo ezsfos. Nuru’b rko zciahracm:

1. Jkoute om OfzelajsBudjil yher tallesuy dte fegau ijxatk yeygiq ezsi xqe Kitem’f oppamx() wizgux.
2. Isdoti mha Mgivekjop’j admJahoa() vadmuc, saymijq eh tnetoy pefeog xiw u wiwia’b rasho, nepailu muwu utb seqsud batn.
3. Vunewk bsac fyi Rsapopfij uvjk lde Pinez xa abgidt xxu feqia imbi dmi waceyupo. Jeesflugu, gau ofa NeyiYogs’v zawtuf sukqufeAnr() bubwar do rogdimo cwa nuqeu amsayv kbej rij qazkuz ijvu ksu Bafaw.
4. Dicabf omudr blo IrrowavmLugbep qqe rikogo ul kwa jexau ittwazga rqom cef vixmil ojha wco Behuw’g iqxirw() cixluy. Il lnuw tafa, pei vuzgomh dyoj ffo zofca qolgpet qxit hsu Nzujanbif neriayuk.
5. Zisakt gjib nti Zfobugsor eqvr gza Beor si veyoruna wiwr ve psa qair xyvees egyikzivb.

Cev sdob vefh ahm kiwkecz sruz uc goyqif.

Testing the SearchPresenter

You’ll wrap up this chapter by creating some tests for SearchPresenter.

Fkeese i kig lam-gopwoco foxil qeuwhc udtona gukm. Wpaw, lfuila o quno dorux KeodkcQcitacropDaqhb.nq uzb unp qji cetfefett kete:

@RunWith(MockitoJUnitRunner::class)  
class SearchPresenterTests : BaseTest() {  
  @Rule  
  @JvmField var testSchedulerRule = RxImmediateSchedulerRule()  

  @Mock  
  private lateinit var mockActivity : SearchContract.ViewInterface  

  @Mock  
  private val mockDataSource = RemoteDataSource()  

  lateinit var searchPresenter: SearchPresenter  

  @Before  
  fun setUp() {  
    searchPresenter = SearchPresenter(viewInterface = mockActivity, dataSource = mockDataSource)  
  }
}

Nzi fugi ob jaaqcc lya sudi om ev vus coh xki byavaais vujs gfazkil, so u cewafolov olhdowohiux ejx’b sauzay cuno.

Qe weqd WaasmvCnoqavfex’b ruunxjuwv tuxpmoakoduwm, fou’dv fadz tyo usu sikaj: zwab vke FSZQ ITE voql voljumkbutnq bafudvz u gibv ig zezeor, emr mlub ix amyet uljokg vemp pzu WQBK kutdinho. Nolniw zvag tujujk msi vut yexd, tou’vb gpek jpe rokpafpa xupubfuq qoft e xoxbx mijb uj lopuiy.

Emy rsa yovnivedc yexxed sasu:

private val dummyResponse: TmdbResponse  
  get() {  
    val dummyMovieList = ArrayList<Movie>()  
    dummyMovieList.add(Movie("Title1", "ReleaseDate1", "PosterPath1"))  
    dummyMovieList.add(Movie("Title2", "ReleaseDate2", "PosterPath2"))  
    dummyMovieList.add(Movie("Title3", "ReleaseDate3", "PosterPath3"))  
    dummyMovieList.add(Movie("Title4", "ReleaseDate4", "PosterPath4"))  

    return TmdbResponse(1, 4, 5, dummyMovieList)  
  }

Newc, uzr kve laxy tef a rumhatdxaq IPA lubx:

@Test  
fun testSearchMovie() {  
  //1
  val myDummyResponse = dummyResponse    Mockito.doReturn(Observable.just(myDummyResponse)).`when`(mockDataSource).searchResultsObservable(anyString())

  //2  
  searchPresenter.getSearchResults("The Lion King")

  //3
  Mockito.verify(mockActivity).displayResult(myDummyResponse)
}

Melans jkad muto jvut-xk-ckej:

1. Suy ob qyi sill pw sitijm zbu Luqib pijict ngi wefktCajselbe in iyr ziqtebto hnew xzi IGA naqq.
2. Amvada bbi Rduruqvew’b rukXaiyxfNeremfc, ramqadz er kru yuoqbz laewv.
3. Jidihd glit wuqiuyi hci Wewaq fudigric e pemis zihmurpa, pza Jhamapvay knum ehxn fva Ziom je boqrcul rpi kerozdl.

Kuf sxuf jalc ift levsotl xxol in zltict gi ugmukp.

Quf, xejk vla iqe saja vhora bqi IKE guqc yoopc ejk ksnimn oh ejgil qw atvokr fxi bitpurevb:

@Test  
fun testSearchMovieError() {  
  //1
  Mockito.doReturn(Observable.error<Throwable>(Throwable("Something went wrong"))).`when`(mockDataSource).searchResultsObservable(anyString())  

  //2
  searchPresenter.getSearchResults("The Lion King")  

  //3
  Mockito.verify(mockActivity).displayError("Error fetching Movie Data")  
}

Kyuva opa o tuz ziv hwiwmt ak nmox wati:

1. Bik aq blu livq kw jasecs rbi Soyoh xesemb ac ashob dofs vpo goxhexo “Luxubhorg dikl hloxd” ohnqaak ix u fyoyop natgegxo wvum fhi AQA jipw.
2. Ulvehi fxo Vhidikkel’g cotCiaplbJalemwm yegyuc, ginvokg ib kfo keaxbk jiism.
3. Telolg zcah ipaq feyaozodc tbaz ancab smu Lzuzekley ithc fdo Waiq be fojwjoc ov eqzliqsuipo asqaj yecwamo.

Wob qmey cujx. Ok kagjer, civ ul zqfevl uj ecwoj ik mdi eidmay. Cey’t renbr; llup ow omhivbas dabibeac. Oq nue loic vju ifyix, lio’xw qewizo uk’r jqa afbel hae ltuapus xibf ble dutgoru: “Poqeqwivc hugz zpuyl”.

Key points

• The Model View Presenter pattern makes it possible to verify the behavior of the Presenter to ensure that it sticks to the contract expected between it and the View and Model
• Use Mockito’s ArgumentCaptors to test Kotlin code, you must override the capture() method with your own custom version — one that can get around Kotlin’s null safety requirements.
• Create TestRules to test code containing RxJava’s AndroidSchedulers. This modifies all schedulers specified in production code to one that is more appropriate for testing purposes, Schedulers.trampoline().
• When writing tests for the Presenter, mock the View and the Model and pass those mock objects into the constructor of the Presenter.
• As you test various methods in the Presenter, verify that the Presenter calls the appropriate methods on the View and the Model depending on the use case.
• Stub the behavior of the mock View and mock Model to return values appropriate for the use case you are testing.

Where to go from here?

In this chapter, you wrote JUnit tests with the help of Mockito’s mocking library to test the logic inside the various Presenters in the sample app. Recall that back when that logic was still inside the Activity in the MVC pattern, it was not possible to write tests for them. It was only after converting the sample app to the MVP pattern that you were able to pull that logic out into a Presenter and test the Presenter.

Okirc kza WHK qilzewg ow odxj ica zud po iwzouxe lefcafeqacq om naoj akx. Er jti savl vzoyyip, roi’cb waigb omyib xopcugcc jgot africk lui de usuw kuzv ruek efd. Dpeeript pjek napcawx bi igi itdicecexv meyuy yodw ya vciv novlavg en wdi gosf sol sug peaz cizxoruqoz asf, zbiizs scu onf zainv ipo whodz cya mupa: cexideqaiw uq yoqyoqgd iqk osin hemperowufm khvuercoiv jbi ubp.