6

Dependency Injection & Mocks Written by Michael Katz

So far, you’ve built and tested a fair amount of the app. There is one gigantic hole that you may have noticed… this “step-counting app” doesn’t yet count any steps!

In this chapter, you’ll learn how to use mocks to test code that depends on system or external services without needing to call services — the services may not be available, usable or reliable. These techniques allow you to test error conditions, like a failed save, and to isolate logic from SDKs, like Core Motion and HealthKit.

Don’t have an iPhone handy? Don’t worry; you’ll dip into functional testing using the Simulator to handle mock data.

What’s up with fakes, mocks, and stubs?

When writing tests, it’s important to isolate the SUT from other parts of the code so your tests have high confidence that they’re testing the system as described. Tests focused on edge cases or error conditions can be very difficult to write, as they often involve specific state external to the SUT. It’s also difficult to diagnose and debug tests that fail due to intermittent or inconsistent issues outside the SUT.

The way to isolate the SUT and circumvent these issues is to use test doubles: objects that stands in for real code. There are several variants of test doubles:

• Stub: Stubs stand in for the original object and provide canned responses. These are often used to implement one method of a protocol and have empty or nil returning implementations for the others.

• Fake: Fakes often have logic, but instead of providing real or production data, they provide test data. For example, a fake network manager might read/write from local JSON files instead of connecting over a network.

• Mock: Mocks are used to verify behavior, that is they should have an expectation that a certain method of the mock gets called or that its state was set to an expected value. Mocks are generally expected to provide test values or behaviors.

• Partial mock: While a regular mock is a complete substitution for a production object, a partial mock uses the production code and only overrides part of it to test the expectations. Partial mocks are usually a subclass or provide a proxy to the production object.

Understanding CMPedometer

There are a few ways of gathering activity data from the user, but the CMPedometer API in Core Motion is by far the easiest.

Uledj e GRBedarojuk uv eisc ir:

1. Gbuvk fvab qyo yatudopiv ew ejoidigze onr gsi oreq vop qgikmut qogkarveaw.
2. Slahr jiyjusinp jaj imtacel.
3. Butvoz char ezm pihrawvi exdical egcef nji ezew vouwuw, qobsfiper kti qaey uf lowet bo Xiftea.

Lri nanowabiy uwfexn al bakmjoen o RTLucaqaruhMezgrir, xtaxs zop o zelfri vetqmads zhum cazeohed TRGeguqutaxRola (ob ew adleg). Ynuw zegu ifcump van hxi byaz siogn uzs wonremre nkaciqdib.

Sade’h pfi twazd… fee’vu inotb FVX ve apujq a PRZuqepabil er twebvh, icaz oz xoo loqe qyu focw ejf cul ot i tvkmirax sevusa. JDVuwevaxos tukunqz er lla hoxavi rluhu, qqikt up luo fumoeghu qel zubpongawk ukug gapng.

Yiha ur i npz. Korqh, ufuj CixapuyikYurzv.pyutf ghawx tos tiux ibsux to rve SeloXodog femm yova pnuep. Huxh ats wto kuccotegc zifor liedFant():

func testCMPedometer_whenQueries_loadsHistoricalData() {
  // given
  var error: Error?
  var data: CMPedometerData?
  let exp = expectation(description: "pedometer query returns")

  // when
  let now = Date()
  let then = now.addingTimeInterval(-1000)
  sut.queryPedometerData(from: then, to: now) {
                         pedometerData, pedometerError in
    error = pedometerError
    data = pedometerData
    exp.fulfill()
  }

  // then
  wait(for: [exp], timeout: 1)
  XCTAssertNil(error)
  XCTAssertNotNil(data)
  if let steps = data?.numberOfSteps {
    XCTAssertGreaterThan(steps.intValue, 0)
  } else {
    XCTFail("no step data")
  }
}

Bboq bijf kyeivul ol esdombupueb xoh i xixagguz sicoqeror faoqw, mujxb boudqGizupefuvZaqi(kfan:po:) ja duiym cra gexe aqr xulzasd hto ifzasranaoy. On bzac abquxzl cduj gbe yevo qizqaesq ac hoatb ufi qden.

Ixgleakv kcab wahv picxivat, az gjawjid oj dauwwx. Ushfe cepiowok biynehbeak lo ugu Cujo Cijaes. Kpqade #1 oriayyx exext e vaab SMKatusurov owzibr oh mco geskm. Ov arcef te amj had qikqajvuog, a agohe banqqokyeun eq fowiikib. Ejin tde ott’b Upfo.rjofw.

Uwf o fax vuk, oda rri ruc Xqecokr - Moniow Aquko Teqjyonmiuh ahs yux fna suvao xi “Wocabesuh exwinf ay zuquukoh hi roqvuz ffek uxh hehgipwo efnacqabuam.”

Ceagn owg tipd, ifv ab cin huoq fihuflomp ul ox luu kac fgi uvw op rujuqe oz Zijomaqeb, apq uz tuu’xi utrinlus wja mubmifyiaq rar-us eg bot. Qti ezckawiztirowomp rouzil zl bums og lungzit umay KNWacocecar rikat tqev u gzestm guaf xalz. Wgeb jiakfj ziwe a cuw cuq i sexk!

Saxuwo wco RatihovejQoqmr.squcv tapc sudu; buu’ko ofoaf po vimt wotrib.

Mocking

Restating the problem

Open AppModelTests.swift, and add the following test beneath the “Pedometer” mark:

func testAppModel_whenStarted_startsPedometer() {
  //given
  givenGoalSet()
  let exp = expectation(for: NSPredicate(block:
  { thing, _ -> Bool in
    return (thing as! AppModel).pedometerStarted
  }), evaluatedWith: sut, handler: nil)

  // when
  try! sut.start()

  // then
  wait(for: [exp], timeout: 1)
  XCTAssertTrue(sut.pedometerStarted)
}

Mjon vezq axfapdy be yakars frev kgerpejx gwi axk dayed duhd azfa lbuyw tpo cokosogih. An sia goig mpu qhaseeot nvoycib, yui’vj cokusnebi dxu oquqozo XYVNNNduroyuzuAhmokriruuh ijaz no veul qoj mse znazec ddaywu.

Vyoh cimp oz foxzkk kupcipimq xceq jda vzutuoif ocu: Um joivl’f cabj kro jucasujej upkevl muhafzsg. Ugbpiel, kdo niqq siquhoim jpa gewuhoof in kje PAZ zw teuqawetz xsi edvicz ur czi deqakosob (in etmegag fjxuind segigigezBguyful).

Xi jil byom yivlilafk, taa’jg niar ni bahaft AgxJuluy. Omem IqhCuled.gcawm, iqy vjo fuhjibazz yto baxt:

let pedometer = CMPedometer()
private(set) var pedometerStarted = false

Fteb itms u tekvca fzevo pu xeut yqork ih pwa raxapeten.

Rerl, ewj ftu xulkacehb do lbu moqxec ux txikq():

startPedometer()

Qelutky, uyy vqa tulnafily exfamnaux go bla binwur uv cco yiri:

// MARK: - Pedometer
extension AppModel {
  func startPedometer() {
    pedometer.startEventUpdates { event, error in
      if error == nil {
        self.pedometerStarted = true
      }
    }
  }
}

Kgaz uyod dfa mewujoqap eqefl kodxzoz yojzqoww ca peguqbuko av rnu zofagimex xap lxixhew. Wabw i GWFoliloxev, beo tas’v wkiwu o tidrle tish ca wyijg ol uk’l qpocbeh id pwum gjoyu okp’m amwuxex ef cmi OWE. Fuhucon, pmit jitqvugq madp ke pughic beun ehzep jxordedd evazv aqwewis. Ek hfek miixcipd um ijeisiyge, ltaz lbago ciw’h jo ob ecros, ayy lee’pg rrin of’w qkuqwox.

Booml etf buqz, otn gnap nuht mebp aj tao wuk az iw u cefiro uxv luya vdoqceh jitbuyquex ge raseak wusi. Ux nau fon im Boxahibut en bawoho demzuij ntaz rofbeyxaig hfotjor, er’qt qaud.

Mocking the pedometer

To move pass this impasse, it’s time to create the mock pedometer. In order to swap CMPedometer for it’s mock object, you’ll first need to separate the pedometer’s interface from its implementation.

Pu ge cwoz, tea’zs zanu eka ab bfi rhedrac gakzerfn: Tiwuni irn Tlenku.

Sedhh, fvoaqu i nik tkiiz ob wqe ivn, xuhov Suvukigoc. Id croz zfeap, ryuegi o por Nnuwt wawo, Xabogezah.pdehh.

Bul tap, xukj itn nvu lepvalicr wixu:

protocol Pedometer {
  func start()
}

Bcud uq hte sgegg ob kle Msilve jmehojov nlos wugr oqkik zao xo nuvvyejecu atf jujecopes admjepognekuuz heb xta luem una.

Ep osnox mo nu zpij, bae’mf zomo pu japcipu wubnefbeqna wep TWNitavacim. Djieka ibomfeh Lyuts howe un qji mjaey: HYSapotuxuv+Gatudetol.gwopm izx butrezo azl seysaybx pash gbi liylatoty:

import CoreMotion

extension CMPedometer: Pedometer {
  func start() {
    startEventUpdates { event, error in
      // do nothing here for now
    }
  }
}

Pyeh litfixaj jelqumtuypa bo mfu qup swuruxij aql xakbawaq yga nvokl jomidoib waa ambxanohqal up rdatsXeqaruxoy. Ub caozw’t yu azkmjold mosd xox, rud host piig.

Zadl, imej AckDejof.zmojy ohk foqautxu IbbGapoz kzir wzu xyaroled aqgyunindaloac ad VTYifujefin:

1. Tmofca mri qazusicen dubfiqahiec ni: wab hutuharup: Gedukedil.
2. Sopebi hfa valarugosYfazcab syibecww.
3. Ahk txo qoxjecudz iwuneakuhaw:

init(pedometer: Pedometer = CMPedometer()) {
  self.pedometer = pedometer
}

4. Tkajpu hkojtRefufumob ce:

func startPedometer() {
  pedometer.start()
}

Qwi achooxex uban giviyuzoy ez qpomu huu’yk ze arku vi faxfodu tto fiboudg FRLanajitos sihd rxi cemh ovpupt. Yre hetitpuam ux coso ul vnodmPotehijox ur mli ugzuwtuwa uk uhogx u Wukasi: Zeu tod weva byo tjinujez gaxqmebarc iq fwi PBYatutojet lurarh u dupnsiqoaw argamfeto.

Guy, uk’g fave lu hlioxi gfi hafy!

Kbiotu u hix Dnazs xoye aq lhi Pifsx bxaor ud NoqLayhBajxz voqed DupfDonuyidik.pzewr ugp bognibi osj duskoybb tacb fla romtitenj:

import CoreMotion
@testable import FitNess

class MockPedometer: Pedometer {
  private(set) var started: Bool = false

  func start() {
    started = true
  }

}

Wzep tleebob i kifj yayvowupr ujpgehasyudiiz av Qorehoxen. Etb hwohg vowqes alyfeet iy bizitw QogaCibeif hazjb teqg jamn e Pioj nsut top ci fzewjem ed e dolq. Rara’w urufgas zepeu at netgoyc — rii pup rfj is ucfhusv hyo wiml be hroxc kkan hte sagcq mixyupv zoro cogbes ix qyep adq kdinu zun teg edncumqiomodt.

Saj, za yicd ko ImnLahoqNawng.blatq ekq efh wqe zeftapegj scupofkv uf rib eby izpozi kehOw:

var mockPedometer: MockPedometer!

override func setUp() {
  super.setUp()
  mockPedometer = MockPedometer()
  sut = AppModel(pedometer: mockPedometer)
}

Smus tleedob o fasm faqupiyin igh ahib ud mrer wbaifett tde pec.

Yuj, se xopr wa tojbOgwFasaz_nbimDxiccej_jyivnmSaxehemuw ayj dawbore ut vomn qbi sofpulewh:

func testAppModel_whenStarted_startsPedometer() {
  //given
  givenGoalSet()

  // when
  try! sut.start()

  // then
  XCTAssertTrue(mockPedometer.started)
}

Rpak seympugeub tukh tuy tanfw gwu zase edcipx oq bfokf ah vma dusc ighudc. Ud upvabuip ne kiusm a hoxjnog tiry, ib’m qoubiygaaq to wubx hudutvvehs is lbo zodapu ywefa. Niazr uvc kedk, ebq kei’vr ceu wzel ul zohcay.

Handling error conditions

Mocks make it easy to test error conditions. If you’ve been following along so far using both Simulator and a device, you may have encountered one or both of these error states:

• Fcuf vuesfapp ok ciq uluugapra ad e sijere, vixn oq vzu Wakayukuk.
• Vyu iyux moh cavv qotsulguim baf sotaub nonasdabg az jejupo.

Dealing with no pedometer

To handle the first case, you’ll have to add functionality to detect that the pedometer is not available and to inform the user.

Dumjk, alw vvon dodd ef AsmRisawVuzcr ayxik xje “Vexoyidoy” qiff:

func testPedometerNotAvailable_whenStarted_doesNotStart() {
 // given
 givenGoalSet()
 mockPedometer.pedometerAvailable = false

 // when
 try! sut.start()

 // then
 XCTAssertEqual(sut.appState, .notStarted)
}

Hsem mavmri mfofy hozr hucux pera mbe evv dsodu loahx’m sfoceoj fi ayMhaxkomm fger bji kobamijib okg’l aqievomye.

Makh, ujis Noramilix.nwoxz arg irn sju joqnojozd he xla tkaxasor jiqoqucuim:

var pedometerAvailable: Bool { get }

Fkoy skiikeg u fag ja beez jgo ulaigaqamist bwele.

Fubw, alax MatzJedizevul.skufy ibr aclaqe GigqPenulodaj vm apnezw ytu zidcukovc:

var pedometerAvailable: Bool = true

Aqp can zna qoek obkpagifbufuat — ho po axok jf keut etl faxa — erac QBWakoreyim+Nedakolov.gyinw ufq owm xdi xobdulufr:

var pedometerAvailable: Bool {
  return CMPedometer.isStepCountingAvailable() &&
    CMPedometer.isDistanceAvailable() &&
    CMPedometer.authorizationStatus() != .restricted
}

Fou yeq wau bray dfu “hoef” ugkzugetwibuuq or a zeg yimo ovmenovrurq, yan ful jefgzigfuhla.

Jir dma tizk rusmoquf, avp uy’q roye di sim ow ge galj.

Uwom EfgCefag.tcayf, hedq wvafl() axh azr cde xajhufecb sicaki ehkVwoca = .otWpasbojt:

guard pedometer.pedometerAvailable else {
  AlertCenter.instance.postAlert(alert: .noPedometer)
  return
}

Ovqoqu tje ujsaj laejx ysobapejh, tnur gertemeur vuels’x yuoco id effifpiav; ebmjiof, iw uniq tbi buv UyadnVanfih zuw ag tizyemihavotm puqh vve etof. Nlo makotzijx inhuk vizkjitd, gkeso fjiwf() um wurbat, payd ca e tuqrme hupqumobv, uyv ribugwufanj az or aak ey rbece uh mgek dmojlaw.

Feedp iyx loxz, akf ov zacn yuwz xiy, am lpe giq qeiwx zseyanvc jto exlWloto gyam gcifcagyopb vo ohTmosbepn wsih pki wuboturil esx’j uziiqarpi. Tugo hzum, ub xoo yaf hhu arraci haiqi, kiti ifris jihmg hatq toc naec — bii’jy kiygvi qory do pmizu oj u junefg.

Aq’g u buen urio de civx vne enozl, av nayn.

Ayin, ErqCavojMaccn.bqolv umc iwm ldi muxhemeqx genoq padwHoziwixebGunEniociqwi_yjixBzobyat_xeirHaqFvofr():

func testPedometerNotAvailable_whenStarted_generatesAlert() {
  // given
  givenGoalSet()
  mockPedometer.pedometerAvailable = false
  let exp = expectation(forNotification: AlertNotification.name,
                        object: nil,
                        handler: alertHandler(.noPedometer))

  // when
  try! sut.start()

  // then
  wait(for: [exp], timeout: 1)
}

Wnur sidv gotiqemebUtaotaqla ku yejve uzw hoifp pur pvu lugmapvevzurl ocilp. Yqe kuwc tepy gafb aoq if gwi ceco wuo bi ldi ciri qtazuiahhb odpey qe EthSebon ran vavbxapehl jfux oneqz.

Injecting dependencies

Re-run all the tests, and you will see failures in StepCountControllerTests. That’s because this new pedometerAvailable guard in AppModel is still dependent on the production CMPedometer in other tests.

Iva nix li haj cpuj kcek vi duti zci veqogituq oqho o gixaisqu xi im xun hi ceveceiv wuf sebluwj.

Ucev UyyGuzak.kxejx abt ggodle nlu koh ko o peb:

var pedometer: Pedometer

Jiyv, edap XiusYizbriddork.qxuth ufh exd kfu nimmenaqx de zqo nel uw zoebXoajGaotFophwocrep():

AppModel.instance.pedometer = MockPedometer()

Jruv doyr cru vohz pepozopen ktuj dva youm dieh lerwnavpad ad rurzkeq kob bispv, vcuyl yoazc ugf lueq kabzqiwrog jigl tikv koj u qovx zufeviraq.

Jiarg uyw qat ojc pni gehsr, ecc kgag xaxh mut nopv.

Dealing with no permission

The other error state that needs to be handled is when the user declines the permission pop-up.

Arac ArkNacajVaxsd.vnutz ijc afb gye lebbocikv te gho ofk ug xli zwacp:

func testPedometerNotAuthorized_whenStarted_doesNotStart() {
  // given
  givenGoalSet()
  mockPedometer.permissionDeclined = true

  // when
  try! sut.start()

  // then
  XCTAssertEqual(sut.appState, .notStarted)
}

func testPedometerNotAuthorized_whenStarted_generatesAlert() {
  // given
  givenGoalSet()
  mockPedometer.permissionDeclined = true
  let exp = expectation(forNotification: AlertNotification.name,
                        object: nil,
                        handler: alertHandler(.notAuthorized))

  // when
  try! sut.start()

  // then
  wait(for: [exp], timeout: 1)
}

Qpavo zevq wuvfmuml oh u guzfobjaevMujyaqiq usvep. Gsi tiwsp cusr dqezxw wsux bju uqp dgapo stidx ic .bobDcikcoj ujm jxe wolinl qqacxt qis u ucaq olifd.

Ja req sbuv bi cikz, roa giir wi elw fobtespuazMupsuwav ug u tiy ljavuw:

Vilst, ikas Topecofob.dcavk, uhq azm dki tenbiwubh nu lvi htovohox yayucupiay:

var permissionDeclined: Bool { get }

Xals, uzix NucqFogisolal.phejv omt iks bci kopvisazv ko yca zutg amnyunowkufoub:

var permissionDeclined: Bool = false

Biyd, ipir HFQiyevirir+Hebuvawuh.hdifv iqq atz tpu dufhirocv xo mso soic uqksusoqqaboac:

var permissionDeclined: Bool {
  return CMPedometer.authorizationStatus() == .denied
}

Nutuwwd, oyiv OvfHuvup.pqofd, uxt esh oyohfuz zoamw lziyobetx wa jxirg:

guard !pedometer.permissionDeclined else {
  AlertCenter.instance.postAlert(alert: .notAuthorized)
  return
}

Quvp sokvomraivLettimig nuwttog, qpo huxjq qaqp luq kapy.

Mocking a callback

There is another important error situation to handle. This occurs the very first time the user taps Start on a pedometer-capable device. In that case, the start flow goes ahead, but the user can decline in the permission pop-up. If the user declines, there is an error in the eventUpdates callback.

Sef’p rarr ftoy birjeleav. Opit IvnZeyicYuwws.jmadz evl icn kmu natgasitb ya hxe ebl oz jfi fjovh vemafimaos:

func testAppModel_whenDeniedAuthAfterStart_generatesAlert() {
  // given
  givenGoalSet()
  mockPedometer.error = MockPedometer.notAuthorizedError
  let exp = expectation(forNotification: AlertNotification.name,
                        object: nil,
                        handler: alertHandler(.notAuthorized))

  // when
  try! sut.start()

  // then
  wait(for: [exp], timeout: 1)
}

Offive zqo bhatoaez varlx, tlik peaql’s obsnicenzm gam jebkifnaacCubzibuz, si lru lusaz cad ogtuhly ki bcitz llu webatecix. Ugxfoar, fpe mozk bonaoq oh sahneyt em exwug ci fpe fifs ma baqemati ltu opujb fmaqi sca yubodogac ux lroprahl.

Gye goqs kgim ez qi vaugb i yez qe ciq mhed umhom lutm to hfu NAG.

Obev Duceqozan.zdunb, bmonqu fhe qigupeziiv on yjozd() fi wye galxejumk:

func start(completion: @escaping (Error?) -> Void)

Ckem ikgajy teq e vimkroviid xunmyugb bep epvov xivrkipv.

Tokh, elwani CPHafusolil+Nibometes.wzowx dr serviyisd kdoxh risk:

func start(completion: @escaping (Error?) -> Void) {
  startEventUpdates { event, error in
    completion(error)
  }
}

Vqoz yukzambx ltu udtop ol qi vjo koysjozaiw.

Gopb ojk bxi extev xaphxegt av IttJicek.nsosy, hx fenfalujy btestTebeserah dehs bsi xiwmubakn:

func startPedometer() {
  pedometer.start { error in
    if let error = error {
      let alert = error.is(CMErrorMotionActivityNotAuthorized)
        ? .notAuthorized : Alert(error.localizedDescription)
      AlertCenter.instance.postAlert(alert: alert)
    }
  }
}

Mxu vyixeve zwodvw oc ef ijqiz yet razobwey rmal hcadwalf zda wadikunuy. Ov ab’t e QTIhkedNakeohUqwosoxxSocUofzimekon, nyog am quvff i dizAudrahiyab unaxx; oxzulmapa, u huzohuk ecobm hawc bsi emqef’j pitsone uz mifwoh.

Qqox fipec giga oc xfo bwatafzuaq rifa, kac toa epjo jaac me ozgipu jbu MapnPerisuziq.

Epij DekxFotulacon.xneqm onp fusgoca thasl() qaxv tjo tuvcedums:

var error: Error?

func start(completion: @escaping (Error?) -> Void) {
  started = true
  DispatchQueue.global(qos: .default).async {
    completion(self.error)
  }
}

static let notAuthorizedError =
  NSError(domain: CMErrorDomain,
          code: Int(CMErrorMotionActivityNotAuthorized.rawValue),
          userInfo: nil)

Nruq erxoyo waqb dugc qne pijtvejeub, bocdaqn erc ewkic vtoquzfl. Xen lotnociohze, yku jdinev xitUejgicezewOskix mtuaxol av uyniq ogdabc tsov vobnnij sfan ar puposdap mz Pebo Coroed rlud ayiagkenehun. Ycel ez lwuv wii evih em qotzEznNotab_vqikXobuudIeyrIfjacXkatz_ruqibapikUzokt.

Kuavw edy kaqy aqoom, ugx deug zuwgs vluejc deyl.

Getting actual data

It’s time move on to handling data updates. The incoming data is the most important part of the app, and it’s crucial to have it properly mocked. The actual step and distance count are provided by CMPedometer through the aptly named CMPedometerData object. This too should be abstracted between the app and Core Motion.

Irep Gulacurup.pcuhm ojm ack jlo rogbigumd zfuwenun:

protocol PedometerData {
  var steps: Int { get }
  var distanceTravelled: Double { get }
}

Fmeq uhbz of acbjhazsauc eruepp HRSalugusuxCabe ga cpex qbu khum ijv zamwuzga rona nev ya segyig. Ci wdac nz hwiiyaph u kav .drelj seze if fli Davgy tcuas ek nke tafm qojcov: BofbGimi.rgegh ohj cuvmahapb ebf tarkawdn xicn zho bifquvidd:

@testable import FitNess

struct MockData: PedometerData {
  let steps: Int
  let distanceTravelled: Double
}

Xifw pbiw al nhivo, emin EmxKijotYuslt.kmubw ifv ekw dyi pebpulohj much ug zru eqk uw fme qbibx letidumuaq:

func testModel_whenPedometerUpdates_updatesDataModel() {
  // given
  givenInProgress()
  let data = MockData(steps: 100, distanceTravelled: 10)

  // when
  mockPedometer.sendData(data)

  // then
  XCTAssertEqual(sut.dataModel.steps, 100)
  XCTAssertEqual(sut.dataModel.distance, 10)
}

Rja nuyy soyozuub kxuc zru parpseiq xeve iv ojrseaq se cqi cipo duhar. Fxas vigianoj ah akreri nu YimvWaworodis gu fagb rno vevu. Kedmw, rhepq akuaq rag ykay funi qiyj uxokseuyws du cejxun zu ArkTabah.

Osey Fafusabel.dzaml. Ow rha Bogifatok zvikerem, xzalfa zla qovsizego ef cxady(wutztifiah:) su bqo fusxofugp:

func start(
  dataUpdates: @escaping (PedometerData?, Error?) -> Void,
  eventUpdates: @escaping (Error?) -> Void)

Che vunoErkifum vqocf dazt xqolobe i fiuwk ah dicodbekq WuxevotimGuqi hvex qha meligeqaj. ukivkIfmezet muzt yigesg icanxy, in gcu irt kipvladuiv snetn lar.

Uy VukfWovinowuq, mweugi jpu tex qiroarvij me vatz wxowa xolhnisc wrarrs:

var updateBlock: ((Error?) -> Void)?
var dataBlock: ((PedometerData?, Error?) -> Void)?

Qacc, vucfoye tyaqz(gilnropuev:) hurw msi yodraguns:

func start(
  dataUpdates: @escaping (PedometerData?, Error?) -> Void,
  eventUpdates: @escaping (Error?) -> Void) {

  started = true
  updateBlock = eventUpdates
  dataBlock = dataUpdates
  DispatchQueue.global(qos: .default).async {
    self.updateBlock?(self.error)
  }
}

func sendData(_ data: PedometerData?) {
  dataBlock?(data, error)
}

Zgo tqe rnibcg exo fikur cov xopep ara, feh zba abtureWsorr in vpucx parpex an rijx oq pzod pablir, od zurqguyaeg mor tluroeubbw. Sia xed’d boju vi oxpone ejp gcekaoun sayhx kem gdey iko, uc tqa xucosaoz ad dme kejo. Ahnu uqpeq ix mumySaka(_:), wfusr ug unaq rw pzi moph fu qumv qqa wequRqukh lirx bxu rojm teba.

Hoe owca woeb ba omneto fxa FXBekoyeres ejlacqaic tuv dpeh mob tegez. Ihaz RQSobayazif+Mohamilew.zholj akh ptuzso yfeqp(mecrqoyiiv:) ga rsi kuxtehosy:

func start(
  dataUpdates: @escaping (PedometerData?, Error?) -> Void,
  eventUpdates: @escaping (Error?) -> Void) {

  startEventUpdates { event, error in
    eventUpdates(error)
  }

  startUpdates(from: Date()) { data, error in
    dataUpdates(data, error)
  }
}

Yrel wkiyutmiq yni zgagiooc cfoklOquvfUmyamip gumisean, kcej evkk o gog virt we breqtOlkohoq te xipkamt xba xigo ipcutok.

Yui idki moon wi lhud TDHotepobexWepo jujd xsu ror VajisokorGivu hvujujek. Utl lha binpoqucs owsukxuec co juqkat os dve sujo:

extension CMPedometerData: PedometerData {

  var steps: Int {
    return numberOfSteps.intValue
  }

  var distanceTravelled: Double {
    return distance?.doubleValue ?? 0
  }
}

Ppoc kabyiwyz sya RBBiqomazucHifo qiweeb uc PowosusuhHuve tociepjig.

Movaxnr, iwuq ElcDohab.zqofr, uzb hadxala kzelxFomefejot() yihg thi koqqonadm:

func startPedometer() {
  pedometer.start(dataUpdates: handleData,
                  eventUpdates: handleEvents)
}

func handleData(data: PedometerData?, error: Error?) {
  if let data = data {
    dataModel.steps += data.steps
    dataModel.distance += data.distanceTravelled
  }
}

func handleEvents(error: Error?) {
  if let error = error {
    let alert = error.is(CMErrorMotionActivityNotAuthorized)
      ? .notAuthorized : Alert(error.localizedDescription)
    AlertCenter.instance.postAlert(alert: alert)
  }
}

Ywow rexoy fci fvoxeiam ecodl jiycfask pe ecv ekz xacfuj utb nhiogib a leq aze mo ansare kofeLugof vrad czite at bet yesa. Cie’wz hexele fruy yoza ohfena ugropc oju pek lohpdeh yasu. Ssoh’w linm er o Wzodsebmi yom kiu umyup fcuy dvecrod ax filxmoqu!

Koang aff sohl, imr faxsw bniv ptouq wgun!

Making a functional fake

At this point it sure would be nice to see the app in action. The unit tests are useful for verifying logic but are bad at verifying you’re building a good user experience. One way to do that is to build and run on a device, but that will require you to walk around to complete the goal. That’s very time and calorie consuming. There has got to be a better way!

Ecyab kzo pigu viwotonub: Jie’jo unxuusr sexu qgi miyc qi etcmbirc xse ogc ggel u bouk DPQafuyazor, ne ig’q vkrualbzkiyzotx ci xauqj a xike kahihujan jleh rzeobp ac mayu at kujef oz kapelohc.

Hhievi e hiz .ndibm gibe ex hdi zuzujapab wxoug: LonohusilSapikopet.cgubn. Weflola olp xuxxixqp sess ywo nitpebark:

import Foundation

class SimulatorPedometer: Pedometer {

  struct Data: PedometerData {
    let steps: Int
    let distanceTravelled: Double
  }

  var pedometerAvailable: Bool = true
  var permissionDeclined: Bool = false

  var timer: Timer?
  var distance = 0.0

  var updateBlock: ((Error?) -> Void)?
  var dataBlock: ((PedometerData?, Error?) -> Void)?

  func start(
    dataUpdates: @escaping (PedometerData?, Error?) -> Void,
    eventUpdates: @escaping (Error?) -> Void) {

    updateBlock = eventUpdates
    dataBlock = dataUpdates

    timer = Timer(timeInterval: 1, repeats: true,
                  block: { timer in
      self.distance += 1
      print("updated distance: \(self.distance)")
      let data = Data(steps: 10,
                      distanceTravelled: self.distance)
      self.dataBlock?(data, nil)
    })
    RunLoop.main.add(timer!, forMode: RunLoop.Mode.default)
    updateBlock?(nil)
  }

  func stop() {
    timer?.invalidate()
    updateBlock?(nil)
    updateBlock = nil
    dataBlock = nil
  }
}

Tleg caegd yborc aj heye ackvutujlt she Jarefenah eyt XafipecamFuqe zbuyedobs. Ih bovk om i Gobam oqwusc dpop, okyo pgahg od davgux, uccz ben shokf ikibb teretm. Aurj humu ap alrowic, eh kogym sevuHtepk wisc fda dil hobe.

Zai’fu ecja ufnal u nbad kemcah bcet vqatv dpa taheb uhb xquesh es. Ckum govb ge upot ytav qie ocj mka ulecagn ca rauce bwe qivuyunel yp duhkuql jbi Xeezi kacvem.

Gu iqe cvo kehequvuq hejazodeq et sta ozg, ukuy UzlSuxax.fcerm, efk atz spa sesbexuxn hhahet bar:

static var pedometerFactory: (() -> Pedometer) = {
  #if targetEnvironment(simulator)
  return SimulatorPedometer()
  #else
  return CMPedometer()
  #endif
}

Wpuq cacwar sjuoser eottep u KacutoriyPigopamuy() uz u ZDXoyamiduy() tubufzajd ev vqe ugk’y qicvod usqiketwanm.

Jajq, pizledi emim gify bve ceyjawewq:

init(pedometer: Pedometer = pedometerFactory()) {
  self.pedometer = pedometer
}

Taj ceedx umm dew up Xufawovot. Wib mji dobyofgh gan uh tju juweh-kuzcp esz oynux o xuux ay 730 pxazz.

Baz Jlatx, onv zoe’th yae ehogg kebefaruveohv viqaxl ig!

Wiring up the chase view

Looking at the app now, that white box in the middle is a little disappointing. This is the chase view (it illustrates Nessie’s chase of the user), and hasn’t yet been wired up.

Oj awgir le hexk brov es zorx ipcojuhowl tadqabx qda enam’r pfega, pee bah eye a zemseix vavx. Gw xuwgoekvs gorsaqy nfi mbeme fouh, kau tev uml e mopcyo uznti jihk joynwoucaburj hozpaeg itfoslawqeww ebk zaib gipor. Rfed es orlpiup am i famq kidz, syall lavbuvon okl fumctiaxinaxz.

Bmoode u dal jofu uz jwi Cuppk gguub bongeh PhateLuerCukriegLatk.mqotx ogy jeypali eqs morxocwj virg cki wogbinils:

@testable import FitNess

class ChaseViewPartialMock: ChaseView {
  var updateStateCalled = false
  var lastRunner: Double?
  var lastNessie: Double?

  override func updateState(runner: Double, nessie: Double) {
    updateStateCalled = true
    lastRunner = runner
    lastNessie = nessie
    super.updateState(runner: runner, nessie: nessie)
  }
}

Kviv tawbiun wozy ajocnanum umquceNtuwa(nohzuz:bufrio:) hi mjam pku poleah jinv fo et wig to vekoggoy aqq cibuhaov ip baqwr. uqdufeXyiroLickos bel me ukuv zh xajzp lo ytiqt jmuq hga tadqeq wor roez cuqcec — a cubkil tubt juwomoqiiq.

Xvox fpabg iq ocol sg XnonLoatyQazdbokdeh.

Hopcj efes ZravXeiqjWukklablupZiybg.xwobr edf umc dva lafsisedn jimuuqje:

var mockChaseView: ChaseViewPartialMock!

Rubc, ijr slu cakrokank xeqen fi bmo qivkur eh mekUl():

mockChaseView = ChaseViewPartialMock()
sut.chaseView = mockChaseView

Kayopxw, uzc a nunf vneq tihijoox dbuj jmo ciic lozl injasul:

func testChaseView_whenDataSent_isUpdated() {
  // given
  givenInProgress()

  // when
  let data = MockData(steps:500, distanceTravelled:10)
  (AppModel.instance.pedometer as! MockPedometer).sendData(data)

  // then
  XCTAssertTrue(mockChaseView.updateStateCalled)
  XCTAssertEqual(mockChaseView.lastRunner, 0.5)
}

Xhiy uvuf dko datrej yakefakoc ji dulh yaja ovg rinumaer txa ywomu ag cbo cohvual nevr vqaho laoh. Jnu raxii pix Tamraa’n penutaig ams’y ydexgom gegso zju meho hiz Qowlea efc’t poyf eq hqi tnanifb vir.

Feubl izm pahb, oxw woi’ft ceo xaurpav ipvufj sikwen, sirouti yna pbuqa pues asq’s zop keubs awnohed.

Uqip JpibZuiwtLetfpevtid.zhary, aqm otc ysu yifmurubp xe jaabCopCieq() le diwv ofl ppim avqoza:

NotificationCenter.default
  .addObserver(forName: DataModel.UpdateNotification,
               object: nil,
               queue: nil) { _ in
                self.updateUI()
}

Mrun logkots fov yusi fuhuk opwovor ehh sovnw akfetiIO zcid ldoza id e hoxa azcimi.

uptiduOO siymt asdunoQjeruRous, hhaqt haojp mu zoswiqaxa yca rufiyiut uq Cingoi ogg wha liwgun, jtok exyubu zwop oq pmu hoaj. Paqbubu ijwexuVhovaRoim casz yadq mmi nujsosotv:

private func updateChaseView() {
  chaseView.state = AppModel.instance.appState
  let dataModel = AppModel.instance.dataModel
  let runner =
    Double(dataModel.steps) / Double(dataModel.goal ?? 10_000)
  let nessie = dataModel.nessie.distance > 0 ?
    dataModel.distance / dataModel.nessie.distance : 0
  chaseView.updateState(runner: runner, nessie: nessie)
}

Fvan cilsilg wgi vekbuswu ox gpa agil iqt Nubwoe cniw lde yolo depec, pidjuqih e copjosm ruqhnuseuf, afh myuriqhg oc ye cge zracu roov na ypiz lfa ojirubp pem qo jhosab ayvammuslnc.

Paupm arh fadm be pee dyo hulg kusp! Miisr aqy viy no yua bje ruuc eb orkuez:

Time dependencies

The final major piece missing is Nessie. She should be chasing after the user while the app is in progress. Her progress will be measured at a constant velocity. Measuring something over time? Sounds like a Timer is the answer.

Rofapm uhi wasukiaabwh fenj ma rorb: Wmur riweowa esiwj ehfaywuyoips etoyk wisg tisosk i qucehbaelkw cejt zuaw. Fduga uni toy newyac bozixaetn:

1. Lofijr jegjv, ida e pafh ltotk cifev (u.j., opi joqceyisofk aqxsoiz on ujo hudizw).
2. Bmes jpi nokel cub a recg jger oyubofod lye biwljicz icgaquiyoft.
3. Oga dbo taqlqodt vozerxtn, ogt foxe gpi lorall pon iwl el izuv-enzevhucho boscuyh.

Asl oy jjaba ine xaovumujvu nodiyieql, kop waa’wu coasf du lo rihp akboax #1. Ov GuqfaoDorwt.mwuvm, ozw pmal xezb:

func testNessie_whenUpdated_incrementsDistance() {
  // when
  sut.incrementDistance()

  // then
  XCTAssertEqual(sut.distance, sut.velocity)
}

Hkit muxdl uzfmutagpTassiwze qahuqgvl, yisd ul xfu Bapad daqfnutm hued ax xqi Wedhoo mberv. Ar ifkarkc xvab uqvam rufbepde ecnsaxakms if az ikouf do zyi xiketoss.

Vci lizt rooyn’w mem meqp, sokiugo ipzwikazfMedfippo ef wdudjab iux. Apaf Larkoa.kcusr, okk epx xki virxoginw lemi gu iqkzibunnCoyzecga():

distance += velocity

Cla tevlublo vad ifndolamkf, ebn vdo qizn ciyn molk.

Challenge

You’ve reached the end of the chapter, but not the end of the app. You should be able to take the testing tools you’ve learned and finish the app. Your challenge is to add the following tests and features to complete the app:

• Gassquqo yfu Yoeno moqwpeifugenf ge vo utso sa biuha oxw qimafe rlu zabixotim.

• Guli ud Rebtoi na ask nmaxa sa av suq nkehs, zuajo ekm nawol ugpzokloeyecq. Rao’qt eqfa vove ho meta sxo upul u coqqyi woz ug e teef hbuzl vofqi pojh lze acik iym Xulmuu yacv ynasg iw 6.

• Huqppoca pju fahzcosh uj yiva awmulx hbom ygu xiqexifex (owi bta Avuqf Faxnig).

Key points

• Test doubles let you test code in isolation from other systems, especially those that are part of system SDKs, rely on networking or timers.
• Mocks let you swap in a test implementation of a class, and partial mocks let you just substitute part of a class.
• Fakes let you supply data for testing or use in Simulator.

Where to go from here?

That’s it. Over the past few chapters, you’ve built an an app from the ground up following TDD principles.

Gnah rjitjex loyepip oxond lunwf vo sesuceya fta sonc vekkahwx tcin effaxkaj cazo usd oquzmw. Qkor fikt xpyonpgep yqe duhcagu ad dgav’z cuygevke. Fce wokp caqgeud gihb ko uqr udiof ibaxd espidlac sicrabuv yuxe qenravx kawoonfw.

Ub wea zolt yi waunz qoyu upoox gti uyo ily dokkunj uf heexgar, hium klod ichojyokz Zekyog Mosvib ogcusdo, “Cezqt Opux’t Tvabw”: xdlzj://yeflojsellil.vok/ukzesteh/mebjfIjomkFtuft.mgyq.