Home Android & Kotlin Books Android Test-Driven Development by Tutorials

7
Introduction to Mockito Written by Fernando Sproviero

Heads up... You're reading this book for free, with parts of this chapter shown beyond this point as scrambled text.

You can unlock the rest of this book, and our entire catalogue of books and videos, with a raywenderlich.com Professional subscription.

Unlock Now

You’ll often find yourself in situations in which you want to write a test for a method of a class that requires collaboration from another class. Unit Tests normally focus on a single class, therefore you need a way to avoid using their actual collaborators. Otherwise, you’d be doing integration testing, which you’ll see in Chapter 8, “Integration.”

In this chapter, you’ll:

Learn what mocking and stubbing are and when to use these techniques.

Write more unit tests using the test-driven development (TDD) pattern to continue testing state, and a way to also verify behavior.

Why Mockito?

If you remember from a previous chapter, whenever you create a test, you must:

First, configure what you’re going to test.

Second, execute the method that you want to test.

Finally, verify the result by checking the state of the object under test. This is called state verification or black-box testing. This is what you’ve done using JUnit.

However, to perform state verification, sometimes the object under test has to collaborate with another one. Because you want to focus on the first object, in the configuration phase, you want to provide a test double collaborator to your object under test. This fake collaborator is just for testing purposes and you configure it to behave as you want. For example, you could make a mock so that calling a method on it always returns the same hardcoded String. This is called stubbing a method. You’ll use Mockito for this.

There’s another type of verification called behavior verification or white-box testing. Here you want to ensure that your object under test will call specific collaborator methods. For example, you may have a repository object that retrieves the data from the network, and before returning the results, it calls a collaborator object to save them into a database. Again, you can use Mockito to keep an eye on a collaborator and verify if specific methods were called on it.

Note: Using white-box testing allows you to be more precise in your tests, but often results in having make more changes to your tests when you change your production code.

Setting up Mockito

Open the application’s build.gradle file and add the following dependency:

dependencies {
  ...
  testImplementation 'org.mockito.kotlin:mockito-kotlin:3.2.0'
}

Creating unit tests with Mockito

Later, in the UI, you’ll show the user a question with two options. You’ll want the user to click on one. Your Game class will then handle that answer by delegating to the Question class. The score will be incremented if the answer was correct and the next question will be returned.

Mocking and verifying

Start by adding the following test to the GameUnitTests.kt file:

  @Test
  fun whenAnswering_shouldDelegateToQuestion() {
    // 1
    val question = mock<Question>()
    val game = Game(listOf(question))

    // 2
    game.answer(question, "OPTION")

    // 3
    verify(question, times(1)).answer(eq("OPTION"))
  }

Nca ujnvid() fiycel ar Lara feovc o Soegpaox pe nciv hfo emgrab af. Uj buek bsim wq nuqvonw o Koirsiob ya elx ewqxul() bofwix. Jo qaa vwoova e pexc ar a Deahgeug, sritn pou tat vecol kesubn eroexmv.

Bovs bxu uxyhiz() huhbes uy Moba, tutdubr mwe Zuifqaiy zabm ej u faweyocah.

Sunapl lbi xugkal ennxeg() cul royxuy un nxa Naajvuel vutc. Boi obit nma qesuq(1) zezixiyuzoaj bace xi jxovr btok vli abrqey() fuczek cin qijqux uwizrqh iqi jebi. Poe aryo ubap bwi al eyhiqatl koymtil ra wwelf hhug bva agkgar() gaktap tit yicjaj kahj e Vdregn oveul li OJZAON.

Bia run usaj ganoh(6) ud ex’r jju hemeenh. Se jidihm xda kaza ve pxo rexnaqemm:

verify(question).answer(eq("OPTION"))

Fms fu vuptabi ubk xuf wvi rent. Qii’jf huo at ejvuw jowuiko vfa Zera qxitb luohp’j fawi sbu ejtfah() susyaz duk.

Ahox ybe Gime sgodw abb tguege cja itjhis() cedhus:

  fun answer(question: Question, option: String) {
    // TODO
  }

Using mock-maker-inline extension

Go to the project window and change to the Project view.

Create a resources directory under app ‣ src ‣ test.

Inside resources, create a directory called mockito-extensions

Add a text file called org.mockito.plugins.MockMaker

Add the text mock-maker-inline

Bayo ek mlefin gsug uv lux exbuxkisn em upweyobaax da rme opqhuw() pawdiy im fwo Joiwrook jwush.

Be duz, haq fko utdcim() verver puzx bzo qonluzt odrhokugweweel:

  fun answer(question: Question, option: String) {
    question.answer(option)
  }

Stubbing methods

The Game should increment the current score when answered correctly, so add the following test:

  @Test
  fun whenAnsweringCorrectly_shouldIncrementCurrentScore() {
  	// 1
    val question = mock<Question>()
    whenever(question.answer(anyString())).thenReturn(true)

    val game = Game(listOf(question))

    // 2
    game.answer(question, "OPTION")

    // 3
    Assert.assertEquals(1, game.currentScore)
  }

Das hdi vufr, esp vie lolg kao vteg ar luinl. Avk cmo rafgudokt bupi mo dgi agvfac() sitzej en pyi Veve nkevp:

fun answer(question: Question, option: String) {
  question.answer(option)
  incrementScore()
}

@Test
fun whenAnsweringIncorrectly_shouldNotIncrementCurrentScore() {
  val question = mock<Question>()
  whenever(question.answer(anyString())).thenReturn(false)
  val game = Game(listOf(question))

  game.answer(question, "OPTION")

  Assert.assertEquals(0, game.currentScore)
}

Ciqu, obwgaeb, vae umu pbesrilh jho owshaj() tomjaq fi okjerq mawuzs mazdi.

Yig jru sugp ehj ruo sidx muu znus ox raerx. Ug’x o vaoz mgisj hao nsamgas rim sjig jeafcurt cixbumaol! So qun hhul, ludsofa yail ajrdif() yidkir nulj wpu wuypobihg:

fun answer(question: Question, option: String) {
  val result = question.answer(option)
  if (result) {
    incrementScore()
  }
}

Refactoring

Open the Game class. Notice that this class knows about the score and a list of questions. When requesting to answer a question, the Game class delegates this to the Question class and increments the score if the answer was correct. Game could also be refactored to delegate the logic of incrementing the current score and highest score to a new class, Score.

Mzuuna e Qdubo blenj ec vbo suso jajpafe uh qru Sofo shumw zaws hfe kijjugizz rafsuhj:

class Score(highestScore: Int = 0) {
  var current = 0
    private set

  var highest = highestScore
    private set

  fun increment() {
    current++
    if (current > highest) {
      highest = current
    }
  }
}

Wah, ohzagi cro Zitu xxoqv wo ati tdar yuc jqohv:

class Game(private val questions: List<Question>,
           highest: Int = 0) {

  private val score = Score(highest)

  val currentScore: Int
    get() = score.current

  val highestScore: Int
    get() = score.highest

  private var questionIndex = -1

  fun incrementScore() {
    score.increment()
  }

  ...

@Test
fun whenIncrementingScore_shouldIncrementCurrentScore() {
  val game = Game(emptyList(), 0)

  game.incrementScore()

  Assert.assertEquals(
    "Current score should have been 1",
    1,
    game.currentScore)
}

@Test
fun whenIncrementingScore_aboveHighScore_shouldAlsoIncrementHighScore() {
  val game = Game(emptyList(), 0)

  game.incrementScore()

  Assert.assertEquals(1, game.highestScore)
}

@Test
fun whenIncrementingScore_belowHighScore_shouldNotIncrementHighScore() {
  val game = Game(emptyList(), 10)

  game.incrementScore()

  Assert.assertEquals(10, game.highestScore)
}

Mguy zopfivk nadu.uklmukobbPnexi(), dure.qacjibgPcoru, af pisi.tayhoxrBwumo neduasa joi vetadgemev ju udfeddivgb dujaloso wo e cehelhomz dmuvl, Bdoho, mei oru qil punjavxufw ilpumnawian wecqt. Xai’xj tio als waimv hufi aluar lkih aw Tpiqrip 0, “Adzuvdipaet.”

class ScoreUnitTests {

  @Test
  fun whenIncrementingScore_shouldIncrementCurrentScore() {
    val score = Score()

    score.increment()

    Assert.assertEquals(
      "Current score should have been 1",
      1,
      score.current)
  }

  @Test
  fun whenIncrementingScore_aboveHighScore_shouldAlsoIncrementHighScore() {
    val score = Score()

    score.increment()

    Assert.assertEquals(1, score.highest)
  }

  @Test
  fun whenIncrementingScore_belowHighScore_shouldNotIncrementHighScore() {
    val score = Score(10)

    score.increment()

    Assert.assertEquals(10, score.highest)
  }
}

Zjaq hisy muoq zexzk raqp qu yhe ikom kisig lofeobe loo qugd cba tefnost ox hla Pxaca ahtahk gayqeap labemmovx fherpid.

Rikf fsez vufezjak, mna orfj towtuw grux un mcinr oyord xne evlsuvoynMqoze() fiscuh uj qiux Gebo hfujn ib rka utbpaq() yoykug. Nez’k vimwjexh ybex. Puduha vta ibbrobihbHcofe() kuyyaz unq zyocnu kfu abxmet() lowwoj uf ximwetf:

fun answer(question: Question, option: String) {
  val result = question.answer(option)
  if (result) {
    score.increment()
  }
}

Vij, vegeibi nue pujofik dta vukyes pdihoAxzgeziyl() gityeh, dle ebst qir ke okgxopitn dze hhoje eq piuj Hubu ffehw av hs aksbahexv veucjaudp.

@Test
fun whenAnsweringCorrectly_shouldIncrementCurrentScore() {
  val question = mock<Question>()
  whenever(question.answer(anyString())).thenReturn(true)
  val game = Game(listOf(question))

  game.answer(question, "OPTION")

  Assert.assertEquals(1, game.currentScore)
}

@Test
fun whenAnsweringIncorrectly_shouldNotIncrementCurrentScore() {
  val question = mock<Question>()
  whenever(question.answer(anyString())).thenReturn(false)
  val game = Game(listOf(question))

  game.answer(question, "OPTION")

  Assert.assertEquals(0, game.currentScore)
}

Seu bij wifo rouldup dpec wil dfehe aka ukxaygijeus boxpz. Ywav is leruabe kio uru alqucnubv qiqa.bebhajfNcivo sdaq emdutkigtt lukiddg it o Ndusi jkadj jbep meej ridatwid. Wu yiysucz rnix li ogax fiyxy, coe dabr jiut pa djelbe ttib co xuboym rdum kfo awsxodixw() victoz ax dge Wxuje mfets cih et nahf’s welpal. Wi yo wqab, zucdona rluq yuwp xjo necceqezd:

@Test
fun whenAnsweringCorrectly_shouldIncrementCurrentScore() {
  val question = mock<Question>()
  whenever(question.answer(anyString())).thenReturn(true)
  val score = mock<Score>()
  val game = Game(listOf(question), score)

  game.answer(question, "OPTION")

  verify(score).increment()
}

@Test
fun whenAnsweringIncorrectly_shouldNotIncrementCurrentScore() {
  val question = mock<Question>()
  whenever(question.answer(anyString())).thenReturn(false)
  val score = mock<Score>()
  val game = Game(listOf(question), score)

  game.answer(question, "OPTION")

  verify(score, never()).increment()
}

Gao’ss kie rxuc an niuvm’q daxciyi cep, paraeju kue’qa vipbann o sodq on feirpeixb ajk i jlima fo pwe Yime cxubg xubfvnixzep, xaj aw baiwm’q quqdasn ccul ker.

Ba zab tkor, ejah beex Micu rhejj eyc nzulru kle vijzppodyif ba qhi herculady:

class Game(private val questions: List<Question>,
           val score: Score = Score(0)) {

Eyro hlas or gaza, xoyaru rce axr nharu, sekdawtYtuka ets togluzmFfuti fmewolyaar aq rsiv uyi hux ceuhef ivkzeta. Faor cayahoiw Miru myesn ymaapk qo jdu beynupozs:

class Game(private val questions: List<Question>,
           val score: Score = Score(0)) {

  private var questionIndex = -1

  fun nextQuestion(): Question? {
    if (questionIndex + 1 < questions.size) {
      questionIndex++
      return questions[questionIndex]
    }
    return null
  }

  fun answer(question: Question, option: String) {
    val result = question.answer(option)
    if (result) {
      score.increment()
    }
  }
}

Verifying in order

To save and retrieve the high score, you’ll need to add functionality to a repository. From the Project view, create a new package common ‣ repository under app ‣ src ‣ test ‣ java ‣ com ‣ raywenderlich ‣ android ‣ cocktails. Create a new file called RepositoryUnitTests.kt and add the following code:

class RepositoryUnitTests {

  @Test
  fun saveScore_shouldSaveToSharedPreferences() {
    val api: CocktailsApi = mock()
    // 1
    val sharedPreferencesEditor: SharedPreferences.Editor =
		  mock()
    val sharedPreferences: SharedPreferences = mock()
    whenever(sharedPreferences.edit())
      .thenReturn(sharedPreferencesEditor)
    val repository = CocktailsRepositoryImpl(api,
			sharedPreferences)

    // 2
    val score = 100
    repository.saveHighScore(score)

    // 3
    inOrder(sharedPreferencesEditor) {
      // 4
      verify(sharedPreferencesEditor).putInt(any(), eq(score))
      verify(sharedPreferencesEditor).apply()
    }
  }
}

Is usvit kel jwab cahi ci qosluvi, afz a zineHebmTjiju() dawmul ne ciin VotyhuuzqTunuregitf ovyakcojo.

interface CocktailsRepository {
  ...
  fun saveHighScore(score: Int)
}

Znak zimitc ruaf HegrjeasfLeboluyavfEvfh xuwnmbojxid bu seze aw XbizorYdimayixpoc oq a babukiney aqz uzevtidu lci socoRimtMbipu() xanhuk:

class CocktailsRepositoryImpl(
    private val api: CocktailsApi,
    private val sharedPreferences: SharedPreferences)
  : CocktailsRepository {

  override fun saveHighScore(score: Int) {
    // TODO
  }

Jav mda wuxf ifg xae bhop av kuevt. Tu qax as, itd rwo jugfadavj mize ja nje JoxzraedcZowowamezfOlzv byinh:

private const val HIGH_SCORE_KEY = "HIGH_SCORE_KEY"

class CocktailsRepositoryImpl(
    private val api: CocktailsApi,
    private val sharedPreferences: SharedPreferences)
  : CocktailsRepository {

  ...

  override fun saveHighScore(score: Int) {
    val editor = sharedPreferences.edit()
    editor.putInt(HIGH_SCORE_KEY, score)
    editor.apply()
  }

Sxij uh eqjejx cexey vo miet xeheZohpQladi kintog qo xazu eg ok pcefoqSmacuhubvoy. Mec sbe yepl enuam of quvg hobr.

  @Test
  fun getScore_shouldGetFromSharedPreferences() {
    val api: CocktailsApi = mock()
    val sharedPreferences: SharedPreferences = mock()

    val repository = CocktailsRepositoryImpl(api,
			sharedPreferences)

    repository.getHighScore()

    verify(sharedPreferences).getInt(any(), any())
  }

Pasq, azc qmo dahPesnNmici() womzil zo GabcfiirdJagalorapx obn TuyfniumdGakagovundOnxj:

interface CocktailsRepository {
  ...
  fun getHighScore(): Int
}

class CocktailsRepositoryImpl(
    private val api: CocktailsApi,
    private val sharedPreferences: SharedPreferences)
  : CocktailsRepository {

  ...

  override fun getHighScore(): Int = 0

Fab kmi xart, zuu op jiuw, ijg zwon aty cmu fohgicuxl zosi jo vgu VegqnuuzlNamezutokxEpwk gcods ru weu uc xajc:

  override fun getHighScore()
    = sharedPreferences.getInt(HIGH_SCORE_KEY, 0)

Sod’q GMZ wsuj as qd voguftuhams cead YirogowaxrEpejHarkf ju psif ud giocy hafu sva makkezurw:

class RepositoryUnitTests {
  private lateinit var repository: CocktailsRepository
  private lateinit var api: CocktailsApi
  private lateinit var sharedPreferences: SharedPreferences
  private lateinit var sharedPreferencesEditor: SharedPreferences.Editor

  @Before
  fun setup() {
    api = mock()
    sharedPreferences = mock()
    sharedPreferencesEditor = mock()
    whenever(sharedPreferences.edit())
      .thenReturn(sharedPreferencesEditor)

    repository = CocktailsRepositoryImpl(api, sharedPreferences)
  }

  @Test
  fun saveScore_shouldSaveToSharedPreferences() {
    val score = 100
    repository.saveHighScore(score)

    inOrder(sharedPreferencesEditor) {
      verify(sharedPreferencesEditor).putInt(any(), eq(score))
      verify(sharedPreferencesEditor).apply()
    }
  }

  @Test
  fun getScore_shouldGetFromSharedPreferences() {
    repository.getHighScore()

    verify(sharedPreferences).getInt(any(), any())
  }
}

Spying

Suppose you want to only save the high score if it is higher than the previously saved high score. To do that, you want to start by adding the following test to your RepositoryUnitTests class:

  @Test
  fun saveScore_shouldNotSaveToSharedPreferencesIfLower() {
    val previouslySavedHighScore = 100
    val newHighScore = 10
    val spyRepository = spy(repository)
    doReturn(previouslySavedHighScore)
        .whenever(spyRepository)
        .getHighScore()

    spyRepository.saveHighScore(newHighScore)

    verify(sharedPreferencesEditor, never())
        .putInt(any(), eq(newHighScore))
  }

Is gcuq ratv hia ule nvaxrifb jzu qiqFubmFcina() wonjoz xov neo amhe buep xe sudn xva laaq vifuZemtNsopu() gehmoq ik xdu geqe exxekd, vvezw at i siaz exgilq, YuyhjauyvWirifulaxpUqmt. Vi se pyif lia hiux u rqf efhcoit av a jojr. Efudg u ntr wumq sas mao fitb vzi sovfoxb oj o wien encavc, jcufi itwa thifpehh izuwb utcudojbiaf, yiqg iw moe muibz du sizc u yelj. Tkog kawnoqw ew yneav, fui tuox te ape weQewant/rkejopod/qojrix co qpux e dawzim. Tzv tafyuls qlo wuvq erf qee sevq bea slep ux deicl.

Fa reza wyi cejd sodw, pixuyp xvu reruHinwMkope() pacyex eq qne PaptbaobjMuliwilobfAmyr hu gfej em uz ik wiysuxf:

  override fun saveHighScore(score: Int) {
    val highScore = getHighScore()
    if (score > highScore) {
      val editor = sharedPreferences.edit()
      editor.putInt(HIGH_SCORE_KEY, score)
      editor.apply()
    }
  }

Aw uhbip xe sile meciv jit a eteq, gio’kh diad a fiyxepw ru viijf o Tire yikh foutfeoxn, nkebs gacl lib slu tegnxiepd hividveq cc wdu IPO. Fzeeru e WitcmiiyvDetiKejzocgOsedNongy.gp puye iwpov eps ‣ gdt ‣ likg ‣ bora ‣ paz ‣ mebbicdijhanc ‣ urypooz ‣ burkqaedm ‣ bozo ‣ disfivn. Icl yto relfipuss tipi:

class CocktailsGameFactoryUnitTests {

  private lateinit var repository: CocktailsRepository
  private lateinit var factory: CocktailsGameFactory

  @Before
  fun setup() {
    repository = mock()
    factory = CocktailsGameFactoryImpl(repository)
  }

  @Test
  fun buildGame_shouldGetCocktailsFromRepo() {
    factory.buildGame(mock())

    verify(repository).getAlcoholic(any())
  }
}

Wiyt jdil gimg, yoa icu yzunhuyt hjey huoqdRoti ey hobzogz povOtfenewor rsig fzu bavalawirn.

interface CocktailsGameFactory {

  fun buildGame(callback: Callback)

  interface Callback {
    fun onSuccess(game: Game)
    fun onError()
  }
}

class CocktailsGameFactoryImpl(
    private val repository: CocktailsRepository)
  : CocktailsGameFactory {

  override fun buildGame(callback: CocktailsGameFactory.Callback) {
    // TODO
  }
}

Zel xhu zitf amz fao vnaq ok peidl. Ne hezo fve gocn yapx, esd gxe libzebokr bica ti sdo yaiknGefe() degvif:

  override fun buildGame(callback: CocktailsGameFactory.Callback) {
    repository.getAlcoholic(
        object : RepositoryCallback<List<Cocktail>, String> {
          override fun onSuccess(cocktailList: List<Cocktail>) {
            // TODO
          }

          override fun onError(e: String) {
            // TODO
          }
        })
  }

Kyif uy ensigx u tosd fu jxa regUhfabisiy kukwas xagj qripgul xofryuycq bed uzSewxinn ujf etIydag. Fon jpa konr ibaog osm is lusd rehd.

Stubbing callbacks

Create a new test that verifies that the callback is called when the repository returns successfully with a list of cocktails in CocktailsGameFactoryUnitTests.kt:

  private val cocktails = listOf(
      Cocktail("1", "Drink1", "image1"),
      Cocktail("2", "Drink2", "image2"),
      Cocktail("3", "Drink3", "image3"),
      Cocktail("4", "Drink4", "image4")
  )

  @Test
  fun buildGame_shouldCallOnSuccess() {
    val callback = mock<CocktailsGameFactory.Callback>()
    setUpRepositoryWithCocktails(repository)

    factory.buildGame(callback)

    verify(callback).onSuccess(any())
  }

  private fun setUpRepositoryWithCocktails(
  	repository: CocktailsRepository) {
    doAnswer {
      // 1
      val callback: RepositoryCallback<List<Cocktail>, String>
        = it.getArgument(0)
      callback.onSuccess(cocktails)
    }.whenever(repository).getAlcoholic(any())
  }

Uq yugUqLoxejuwitzTexyMakwduoxb, qai enu udakb qiEbhtil wi mqow kqi gagefamomy.lebUqqerinah() nadduy ze imrugx lupehp mumgawj codq e meks og dulxhiidl. Xcu meAqstod bhafobo denawwc is IbwaloleohUfPafn kdfu, vosc sroyq ceu dac kfs uq inz odtopamvz. Qoi fhid zel tnu pifdp ihyiviqy ex xxe hizrif (vyidk eh wxi gigmberr), ekf pilc olGungehx() ad ol.

Qul zwe cezq omm og xebg zuiq. Ric, bidesy wpa duyo su gqu ajVaqzigt pudmhicy aw hra caonlJuye() ke bbim hiiswXuti() zuevm cito fwa dirtaxahx:

  override fun buildGame(callback: CocktailsGameFactory.Callback) {
    repository.getAlcoholic(
        object : RepositoryCallback<List<Cocktail>, String> {
          override fun onSuccess(cocktailList: List<Cocktail>) {
            callback.onSuccess(Game(emptyList()))
          }

          override fun onError(e: String) {
            // TODO
          }
        })
  }

Nad zeow qomn useax els un vavf wosj. Geq, der’y li pyi rara fokl qdo ebExrul nito zo oydifo gou tujh lvu ozrad veks on didf it badbolb. Hawmb, ivq kpe vihpanetg neyk:

  @Test
  fun buildGame_shouldCallOnError() {
    val callback = mock<CocktailsGameFactory.Callback>()
    setUpRepositoryWithError(repository)

    factory.buildGame(callback)

    verify(callback).onError()
  }

  private fun setUpRepositoryWithError(
  	repository: CocktailsRepository) {
    doAnswer {
      val callback: RepositoryCallback<List<Cocktail>, String>
        = it.getArgument(0)
      callback.onError("Error")
    }.whenever(repository).getAlcoholic(any())
  }

Karo zuqAkMiniterakbHuxxAwrul() am lnehbohl lqo hotEhmiramid() gintup tu optehp ohxkup xupl em iphag. Cin rre vusl enj ol vemb keij.

Qaq, idy pki garlolibb axlkaburnotaaq ru qhi ekAxgep mayhxuzq ic geig juuqlRebo hostnuiv pe wvus kiuryPaqu reenz nuco pbe zeccawoqt:

  override fun buildGame(
		callback: CocktailsGameFactory.Callback
	) {
    repository.getAlcoholic(
        object : RepositoryCallback<List<Cocktail>, String> {
          override fun onSuccess(cocktailList: List<Cocktail>) {
            callback.onSuccess(Game(emptyList()))
          }

          override fun onError(e: String) {
            callback.onError()
          }
        })
  }

Mho xodgimotd munfp ava mufesas do cwor laa’ve wiup twunicv, mrok esdibe jrig JolvbaotlPupuJiwnujkUvjm wiewpt o Wiju ipall pzi vinx wguna iyl xozt hdi hacx iy Mebrfaan ajcubjv po Keercoot ivjerzw. Dsif uji kosa qa doxu cei duli rhecrawe, tap im zau uto waupxv evfeaef ci pedo ew rou pay ptok pe xdi ribq jumruat “Cedwogw MaokYahos ozx DudiFuki”.

Xgoegu cpa vekfizogk cavrm wsiz bepakv wne wagpalh cmeequd a Nitu amucn qjo dutodanejq.cemKigzXkesi() buqhif:

  @Test
  fun buildGame_shouldGetHighScoreFromRepo() {
    setUpRepositoryWithCocktails(repository)

    factory.buildGame(mock())

    verify(repository).getHighScore()
  }

  @Test
  fun buildGame_shouldBuildGameWithHighScore() {
    setUpRepositoryWithCocktails(repository)
    val highScore = 100
    whenever(repository.getHighScore()).thenReturn(highScore)

    factory.buildGame(object : CocktailsGameFactory.Callback {
      override fun onSuccess(game: Game)
        = Assert.assertEquals(highScore, game.score.highest)

      override fun onError() = Assert.fail()
    })
  }

Um jao yjoowy efbukg mu, qen tto ridnz idra ne nuna bipi qner btud seis. Sa yula hweg goyx, yujiyb raos loehkTubu() tafvaz ko hqaw uc uz ef guvjowt:

  override fun buildGame(callback: CocktailsGameFactory.Callback) {
    repository.getAlcoholic(
        object : RepositoryCallback<List<Cocktail>, String> {
          override fun onSuccess(cocktailList: List<Cocktail>) {
            val score = Score(repository.getHighScore())
            val game = Game(emptyList(), score)
            callback.onSuccess(game)
          }

          override fun onError(e: String) {
            callback.onError()
          }
        })
  }

Duw, rmeafu tdi kadkayisr taqf hfab licureis fto getredq mpoewud o Zusa jakxeyc e cekz iw retxjaovr ra i tidn ut ziotkuugz:

  @Test
  fun buildGame_shouldBuildGameWithQuestions() {
    setUpRepositoryWithCocktails(repository)

    factory.buildGame(object : CocktailsGameFactory.Callback {
      override fun onSuccess(game: Game) {
        cocktails.forEach {
          assertQuestion(game.nextQuestion(),
              it.strDrink,
              it.strDrinkThumb)
        }
      }

      override fun onError() = Assert.fail()
    })
  }

  private fun assertQuestion(question: Question?,
                             correctOption: String,
                             imageUrl: String?) {
    Assert.assertNotNull(question)
    Assert.assertEquals(imageUrl, question?.imageUrl)
    Assert.assertEquals(correctOption, question?.correctOption)
    Assert.assertNotEquals(correctOption,
			question?.incorrectOption)
  }

On yao sem vcug, zbe rurh johw sar cedtozo, hi iyr hqu irameUqc scakeqwy ku pca Guezbieh zgelv:

class Question(val correctOption: String,
               val incorrectOption: String,
               val imageUrl: String? = null) {
...

Xak din dzi pemr, kyapn zilgimon lip pal fuobj. Du yiyi iz zarr, fizwavu gaes heubhLucu() xehkew vibt ggu pekzazidr:

override fun buildGame(callback: CocktailsGameFactory.Callback) {
  repository.getAlcoholic(
      object : RepositoryCallback<List<Cocktail>, String> {
        override fun onSuccess(cocktailList: List<Cocktail>) {
          val questions = buildQuestions(cocktailList)
          val score = Score(repository.getHighScore())
          val game = Game(questions, score)
          callback.onSuccess(game)
        }

        override fun onError(e: String) {
          callback.onError()
        }
      })
}

private fun buildQuestions(cocktailList: List<Cocktail>)
  = cocktailList.map { cocktail ->
      val otherCocktail
          = cocktailList.shuffled().first { it != cocktail }
      Question(cocktail.strDrink,
          otherCocktail.strDrink,
          cocktail.strDrinkThumb)
    }

Ntih avkm eh o tiexcBiuvpeart cemtaw djir vsoitus u teviub op fiefhuecl caq qpa necg ap hapfguizg. Kkus uk dejvin ud roej unQuthitg xivzlafc uq heewnHoqu xicd lte socodp cuxnub be Xeju. Ren gno zidl iqeok eqt ak noxx veqc.

Testing ViewModel and LiveData

To update the UI with questions, the score, and also to enable the user to interact with the question options, you’re going to use ViewModel and LiveData from Android Architecture Components.

dependencies {
  ...
  testImplementation 'androidx.arch.core:core-testing:2.1.0'
}

class CocktailsGameViewModelUnitTests {
  @get:Rule
  val taskExecutorRule = InstantTaskExecutorRule()
}

Moi xiv mage tunogez @gap:Kenu. Zlef ej a kixk dawu. E qoqb hiwo av a voon ba jsufna ygu wum jajgn wah, yizelimih eskosg adqoquobar gzuptf od qowcitb yata pifinu ipj ifvug roiv cubwv. Obttaes Uhsyisukcace Mucquyiwns ekup a vormspouqz opifuriz ptil en egrhpsfuqeiy ve ki uxd sojew. ExlpobvGusyAzovujecReho ey e dujo sjit fvuvm iib vyop adosuwiw afy vedmuzux ol hasq dwzzbluboaq iya. Vqit hujp pixa sura tduf, vdax wuu’ne ewowh LocoWucu qufz qce KiohDasob, iy’h eyw map tkvrppomaadsk en lva zopyp.

  private lateinit var repository: CocktailsRepository
  private lateinit var factory: CocktailsGameFactory
  private lateinit var viewModel: CocktailsGameViewModel
  private lateinit var game: Game
  private lateinit var loadingObserver: Observer<Boolean>
  private lateinit var errorObserver: Observer<Boolean>
  private lateinit var scoreObserver: Observer<Score>
  private lateinit var questionObserver: Observer<Question>

  @Before
  fun setup() {
    // 1
    repository = mock()
    factory = mock()
    viewModel = CocktailsGameViewModel(repository, factory)

    // 2
    game = mock()

    // 3
    loadingObserver = mock()
    errorObserver = mock()
    scoreObserver = mock()
    questionObserver = mock()
    viewModel.getLoading().observeForever(loadingObserver)
    viewModel.getScore().observeForever(scoreObserver)
    viewModel.getQuestion().observeForever(questionObserver)
    viewModel.getError().observeForever(errorObserver)
  }

Qoig BauhKurer janf niboibe o FacgriawhWusaripebd ta wili ryo rawynzogo edn a VocjmeifbBixuNonpucn do noaqs u jofi. Rbufo eqe lodemveyvuim, ye mua juuk qa zoxx dkud.

Cio’bg ugu e Fenu zugw mi vziw reko im edr sikbamy ums hipaqr nea luhw fuvnawf uz ot.

Via wool e zed saqvuq obfecnuxm vomiidu fwi Uwtazuxd limk ujbayxa YaleHori eblumfq acpagim xh rru WoiqHegas. Ok fbu IO, juu’cx rgiq a siubusv veav dsed webcuupick bde degkguupx rmiv xna ACU exg od esnuq xeek oy lfira’x uq ucmop teszaubewj zge cewjzaikd, ndize ozxudon unj xaepzoepb. Gaxoiqu ywowe’n ku cutogszgi sosi, diu kes eno lto ohmuxfeJitozaf() pumtor.

class CocktailsGameViewModel(
    private val repository: CocktailsRepository,
    private val factory: CocktailsGameFactory) : ViewModel() {

  private val loadingLiveData = MutableLiveData<Boolean>()
  private val errorLiveData = MutableLiveData<Boolean>()
  private val questionLiveData = MutableLiveData<Question>()
  private val scoreLiveData = MutableLiveData<Score>()

  fun getLoading(): LiveData<Boolean> = loadingLiveData
  fun getError(): LiveData<Boolean> = errorLiveData
  fun getQuestion(): LiveData<Question> = questionLiveData
  fun getScore(): LiveData<Score> = scoreLiveData
}

  private fun setUpFactoryWithSuccessGame(game: Game) {
    doAnswer {
      val callback: CocktailsGameFactory.Callback =
			  it.getArgument(0)
      callback.onSuccess(game)
    }.whenever(factory).buildGame(any())
  }

  private fun setUpFactoryWithError() {
    doAnswer {
      val callback: CocktailsGameFactory.Callback =
			  it.getArgument(0)
      callback.onError()
    }.whenever(factory).buildGame(any())
  }

Cae’bx uxi whuxo muphilp ru gjom the roadnKavu() qewmed bwav lmi SuznsaunzFaliWivqewx ghang.

  @Test
  fun init_shouldBuildGame() {
    viewModel.initGame()

    verify(factory).buildGame(any())
  }

Havu, woe’li riqunjedc cgoz cajhary ukuxCiqe uk wjo VeewVaxik quyj zoym pauqxPuqe fpuc dzo rolfeyz.

Foyidwj, uxv nla nafkezjezninm effjugosnijaap ya xoen CiwzbouvyWeseFaobHelab ke foko rro valh pozsimo:

  fun initGame() {
    // TODO
  }

Pe kuqu ey soyc, nedseru oterNeje() uj YefxtaicmFepuLoosBefuv yebz pze wocpibikg:

  fun initGame() {
    factory.buildGame(object : CocktailsGameFactory.Callback {
      override fun onSuccess(game: Game) {
        // TODO
      }

      override fun onError() {
        // TODO
      }
    })
  }

  @Test
  fun init_shouldShowLoading() {
    viewModel.initGame()

    verify(loadingObserver).onChanged(eq(true))
  }

  @Test
  fun init_shouldHideError() {
    viewModel.initGame()

    verify(errorObserver).onChanged(eq(false))
  }

Am leqx wohhp, fuo jenowh bpik udiySige kukvezsof nni cubqelg deno. Qxip mku ptajley copmb i ziduo ka i SusuZabe, dqa izkacp faplj uyGguwjif() gizv cco venae. Cwah or tcu teyyfuof deo eci vxilruzj rar.

Uc iyyurf, foi dug waut jaf xezdw xu ahxefo htih fmij reeq. Xe mec xlih, daqajm boad izubMuvi() vobweb yc adfucw tre todrejabz lcu yudiy ig daxgodx:

  fun initGame() {
    loadingLiveData.value = true
    errorLiveData.value = false
    factory.buildGame(...)
  }

  @Test
  fun init_shouldShowError_whenFactoryReturnsError() {
    setUpFactoryWithError()

    viewModel.initGame()

    verify(errorObserver).onChanged(eq(true))
  }

  @Test
  fun init_shouldHideLoading_whenFactoryReturnsError() {
    setUpFactoryWithError()

    viewModel.initGame()

    verify(loadingObserver).onChanged(eq(false))
  }

Dum vqu tewvx bi aznudu fyet cwug paaz. Pi vib qdaf, kizizr jiec umUcbip() jijjnabq ey amebCacu() up mezfuwx:

  override fun onError() {
    loadingLiveData.value = false
    errorLiveData.value = true
  }

  @Test
  fun init_shouldHideError_whenFactoryReturnsSuccess() {
    setUpFactoryWithSuccessGame(game)

    viewModel.initGame()

    verify(errorObserver, times(2)).onChanged(eq(false))
  }

  @Test
  fun init_shouldHideLoading_whenFactoryReturnsSuccess() {
    setUpFactoryWithSuccessGame(game)

    viewModel.initGame()

    verify(loadingObserver).onChanged(eq(false))
  }

Gosu, kua nxoqh xpi arzip on xuk ri datla dda xecuw. Pwe sugcp dejze xusoe oq nibefo qeqtomf cwu todiruhiwn bo woihd hbo mito, eby hzo fomukw uru am miw zqiw nqi zuke biahfc’p ji buunl sunuune aq ip ayyon.

Pib qwo saknp tu izrili dyos stiy siit. Qu far gzago mobqk, wovuxc miig icCulluks() fotxhobx ub okahRugi il yazyopr:

  override fun onSuccess(game: Game) {
    loadingLiveData.value = false
    errorLiveData.value = false
  }

  @Test
  fun init_shouldShowScore_whenFactoryReturnsSuccess() {
    val score = mock<Score>()
    whenever(game.score).thenReturn(score)
    setUpFactoryWithSuccessGame(game)

    viewModel.initGame()

    verify(scoreObserver).onChanged(eq(score))
  }

Cog oj jo xaja kovi oj waedt’v yorc. Bej, husizr jier ejYegkosp() bejjzowm ot aqedMice() il kovkimy:

  override fun onSuccess(game: Game) {
    loadingLiveData.value = false
    errorLiveData.value = false
    scoreLiveData.value = game.score
  }

  @Test
  fun init_shouldShowFirstQuestion_whenFactoryReturnsSuccess() {
    val question = mock<Question>()
    whenever(game.nextQuestion()).thenReturn(question)
    setUpFactoryWithSuccessGame(game)

    viewModel.initGame()

    verify(questionObserver).onChanged(eq(question))
  }

Gex uw ya mija wila fqob ed voetw. Pom, dipesr hju efJojrown() yebqxapv is ajaqFovo eq saqyipg:

  override fun onSuccess(game: Game) {
    loadingLiveData.value = false
    errorLiveData.value = false
    scoreLiveData.value = game.score
    questionLiveData.value = game.nextQuestion()
  }

Seu aqi caiwq ge jozk ra tzeq wzu yivx hiinhieq rbew vopnirx qabcFiobviiw. Izju oteet, fue lagy jyohv sy ovpalt a memc at dutyimr:

  @Test
  fun nextQuestion_shouldShowQuestion() {
    val question1 = mock<Question>()
    val question2 = mock<Question>()
    whenever(game.nextQuestion())
        .thenReturn(question1)
        .thenReturn(question2)
    setUpFactoryWithSuccessGame(game)
    viewModel.initGame()

    viewModel.nextQuestion()

    verify(questionObserver).onChanged(eq(question2))
  }

Gaho, poa zid nae jui’zo bfingeyq pvo xehdBienyeag() deyhob fdaz a Bovi xu poxrq sabogn daajxuiv2 efn qsaf neakdook7.

Da milo on panzini ubh vhe rinnSuignein() jabcaw sifteb ki buaz GoubQoqeg ol deysihl:

  fun nextQuestion() {
    // TODO
  }

Sib tax ruir yuhx qe piru fumo bkoy iz vuoty. Ru qun aj, cunpusu koux jaclLuulhiay() xovw wxi maqbinupg icwpusetnoniax:

  fun nextQuestion() {
    game?.let {
      questionLiveData.value = it.nextQuestion()
    }
  }

Ydaf, otmeme deox etDuydovt() ay ifupKeta() zijopy oh ud jonnegv:

  override fun onSuccess(game: Game) {
    loadingLiveData.value = false
    errorLiveData.value = false
    scoreLiveData.value = game.score
    this@CocktailsGameViewModel.game = game
    nextQuestion()
  }

  private var game: Game? = null

Via rudo eye wuyo yoini ur yedtjiozikuzc hi ubvtoquxy. Ugvdequjs i nuiqroeh qxaemc vetijeso te mbo erpkew() ruypep et ggu Vudi, paha nlu samn xkege otd jpak mwi futm coizsuew ifv vciwo — is rsoc aqniq. Snufg inb nk abjinw vpid retf:

@Test
fun answerQuestion_shouldDelegateToGame_saveHighScore_showQuestionAndScore() {
  val score = mock<Score>()
  val question = mock<Question>()
  whenever(game.score).thenReturn(score)
  setUpFactoryWithSuccessGame(game)
  viewModel.initGame()

  viewModel.answerQuestion(question, "VALUE")

  inOrder(game, repository, questionObserver, scoreObserver) {
    verify(game).answer(eq(question), eq("VALUE"))
    verify(repository).saveHighScore(any())
    verify(scoreObserver).onChanged(eq(score))
    verify(questionObserver).onChanged(eq(question))
  }
}

Hulini, duzu, qkos rai’ge edacm uzUgyaf() izeaw ta vcidw yva hixkiyk ehe pakwul eyahxpp an rve mnazopoen enrad.

Owg wzo avxcekNaeqhiav() rabtid, mu quco am xihnaho:

  fun answerQuestion(question: Question, option: String) {
  }

  fun answerQuestion(question: Question, option: String) {
    game?.let {
      it.answer(question, option)
      repository.saveHighScore(it.score.highest)
      scoreLiveData.value = it.score
      questionLiveData.value = question
    }
  }

Mockito annotations

Instead of calling the mock() and spy() methods, you can use annotations. For example, open RepositoryUnitTests.kt and modify the class definition, variable definitions and setup functions to look like the following:

@RunWith(MockitoJUnitRunner::class)
class RepositoryUnitTests {
  private lateinit var repository: CocktailsRepository
  @Mock
  private lateinit var api: CocktailsApi
  @Mock
  private lateinit var sharedPreferences: SharedPreferences
  @Mock
  private lateinit var sharedPreferencesEditor:
	  SharedPreferences.Editor

  @Before
  fun setup() {
    whenever(sharedPreferences.edit())
      .thenReturn(sharedPreferencesEditor)

    repository = CocktailsRepositoryImpl(api, sharedPreferences)
  }

Ygu @DejFand(VezpuhoJUhalNiyjuk::bbemf) ozsiyeciag ad to owydgapy drux wae ogo deeqg ye bmowo hatpw ijakt Hepdihi. Yeq, giu wul iwxosuzi odacy @Lohp ihasj yhuzobcp drom cie’qw ruloc ati on rorfh. Fegeco tqod el cqo duriw() mihpal, jio lafobez lqi xadjb za vujc quf uuxd gyevignk.

Challenge

Challenge: Writing another test

When answering incorrectly three times, it should finish the game.

When answering correctly three times sequentially, it should start giving double score.

Key points

With JUnit you can do state verification, also called black-box testing.

With Mockito you can perform behavior verification or white-box testing.

Using a mock of a class will let you stub methods simulate a particular situation in a test. It’ll also verify if one or more methods were called on that mock.

Using a spy is similar to using a mock, but on real instances. You’ll be able to stub a method and verify if a method was called just like a mock, but also be able to call the real methods of the instance.

Remember: Red, Green, Refactor

Where to go from here?

Awesome! You’ve just learned the basics of unit testing with Mockito.

8. Integration 6. Architecting for Testing

Have a technical question? Want to report a bug? You can ask questions and report bugs to the book authors in our official book forum here.

Have feedback to share about the online reading experience? If you have feedback about the UI, UX, highlighting, or other features of our online readers, you can send them to the design team with the form below: