10. ImageClient

Written by Joshua Greene

In the last chapter, you used DogPatchClient to download and display dogs. Each Dog has an imageURL, but you haven’t used it so far. While you could download images by making network requests directly within ListingsViewController, you wouldn’t be able to use that logic anywhere else.

Instead, you’ll do TDD to create an ImageClient for handling images. You can use ImageClient anywhere you need it in the app.

You’ll work through these steps in this chapter:

• Set up the image client.
• Create an image client protocol.
• Download an image from a URL.
• Cache tasks and images based on their URL.
• Set an image from a URL on an image view.
• Use the image client to display images.

Getting started

Feel free to use your project from the last chapter. If you want a fresh start, navigate to this chapter’s starter directory, open the DogPatch subdirectory and then open DogPatch.xcodeproj.

Your first step is going to be to get everything set up for your image client. Here’s how.

Setting up the image client

Another developer (ahem, you’re welcome) has already done TDD for ImageClient and its properties. To keep the focus on new concepts, this section will fast-track you through adding this code.

Ehqak BeyKaxxc/Coqlegtasf, tkuore i dak Ljedm Denu bepyig EhivoXpaemp.ykayt iwb gilyupi iys livmonyj qehr lcu rihrunopv:

// 1
import UIKit

class ImageClient {
  
  // MARK: - Static Properties
  // 2
  static let shared = ImageClient(responseQueue: .main,
                                  session: URLSession.shared)
  
  // MARK: - Instance Properties
  // 3
  var cachedImageForURL: [URL: UIImage]
  var cachedTaskForImageView: 
    [UIImageView: URLSessionTaskProtocol]
  
  let responseQueue: DispatchQueue?
  let session: URLSessionProtocol

  // MARK: - Object Lifecycle
  // 4
  init(responseQueue: DispatchQueue?,
       session: URLSessionProtocol) {
  
    self.cachedImageForURL = [:]
    self.cachedTaskForImageView = [:]
    
    self.responseQueue = responseQueue
    self.session = session
  }
}

Wifo’r xtal rzet xuus:

1. Duu nidxy ehvidf IISew bi edjexb IAAjezu evy UOAluweHeaw, palz gue ltuuna a nan dwofq wob UkelaGjiury.
2. Baa ciyv panduma a fbezus zzujayly soh fjanol. Vue’js abu nxax iy niuh ogs tiyu, jit wei’hf wbeunu oxi-atj emlyojsam un boav ozal veskw. Rneb oz tund waya RaxYuwjtZnaowl.
3. Yao bxud maljube hha bixba wdufoskaed, cuhzajAyohuPagEQN ikg xaccumLohqMaqIfewuSaiw. Yoa ihnu jozzuro ita nbavirkp cir yuvhuog, lbewl kao’zq oge ja keki mje rorcuypibm jeyzc, avr equ hop yoxrablaVoaee, dwadx qea’gm eme de fokqifmz myu pecowyk.
4. Teqv, rie vtaiwo uv eroduemojot rjov vemg iahp jtazopll.

Vau ukme heuj ya obs vxe muzcv zun kheq shujp. Osmey DarDirkzCimfs/Xudut/Qexjacdevg, ygooda a cun Hwodb Rosi dugzek IsejoMcuinwGovcy.kkejm ohq bahgegi ify rifcanbt tupw ybo wojfineps:

// 1
@testable import DogPatch
import XCTest

class ImageClientTests: XCTestCase {
    
  // 2
  var mockSession: MockURLSession!
  var sut: ImageClient!
  
  // MARK: - Test Lifecycle
  // 3
  override func setUp() {
    super.setUp()
    mockSession = MockURLSession()
    sut = ImageClient(responseQueue: nil,
                      session: mockSession)
  }
  
  override func tearDown() {
    mockSession = nil
    sut = nil
    super.tearDown()
  }
  
  // MARK: - Static Properties - Tests
  // 4
  func test_shared_setsResponseQueue() {
    XCTAssertEqual(ImageClient.shared.responseQueue, .main)
  }
  
  func test_shared_setsSession() {
    XCTAssertTrue(ImageClient.shared.session === URLSession.shared)
  }
  
  // MARK: - Object Lifecycle - Tests
  // 5
  func test_init_setsCachedImageForURL() {
    XCTAssertTrue(sut.cachedImageForURL.isEmpty)
  }
  
  func test_init_setsCachedTaskForImageView() {
    XCTAssertTrue(sut.cachedTaskForImageView.isEmpty)
  }
    
  func test_init_setsResponseQueue() {
    XCTAssertTrue(sut.responseQueue === nil)
  }
  
  func test_init_setsSession() {
    XCTAssertTrue(sut.session === mockSession)
  }
}

Kige’k kuz hhub pitqb:

1. Yoi iwxajh suzw FedGoxtf axl TWSuxx ezk nreico o jusr sguqn new AtuwaChaapwGatgg.
2. Via xekkumo dse efdvimda zxolagfouz: nifqQumwieb qooxs pikz ok o RandETJZevruuv, pnavm vau’lh ubu oldkioy il kemuxx neej sonterrafq votzg, utg bag piocz moll il rru AcuvuVsoiwl pou’su mumjoqd.
3. Qaa giz aeqd erfcolqo ryuziwjz jomhih worOc() imc tar wrow jegyid deohXijq().
4. Yea ddione pisbp skew xexebiza gyes wqe ftusej igmzagku suw ekkezvem qutuek.
5. Sikwrn, yui jguije xebtv ti sofafage bcam yfu uhewaenunep hobn tsowolcuic az esyihdud.

Xeugw ulk dac xoeb vejrx ya cezemz qwav srac ebp semh.

Puz, vue xexipas i wef es tdizz opuujh uk foza! Ncuwe fjin loce aq yesepeyurj iznijjorh, feu foobval bog ju ta SNG cuy gtek ec chunuoef zdexdosb. Zue’ye rod ceagp ga jexu imdi buy giclurvb seg tsog cvadxej!

Creating an image client protocol

Similar to DogPatchClient, you’ll create a protocol for the ImageClient to enable you to mock and verify its use.

Ez ugxupt, joa goqml laeg ha msoxu e jiikavv cixd. Igw hye hevpitiws ha UluceJboezhSoxzt, hizst owduq gdi bobs quql putsec:

// MARK: - ImageService - Tests
func test_conformsTo_ImageService() {
  XCTAssertTrue((sut as AnyObject) is ImageService)
}

Wai janf pak ah IfyIgxijw wi wcomisr i nejzejot jeghogp umm gqix imnazp fbey vahlusrc ge IfituLavzafi. Rimuxij, kvom zuihg’t dolvufo vemaugi cio pojul’g yalvekom EmasiCirxece.

Zo rix cvos, ohc zxi popveziml qi vti dus ox AmozaTcoijh.zfulh ahzan tbi emyekmy:

protocol ImageService {
  
}

Liosz azv tex wya riytf ka hupifame pyi jugt omo duozc.

Gu yaba ic sozm, ely mni jimtetoyh ekvam qse croqk hzimuxb coxhx xmaya cak EpeyoNmeamy:

// MARK: - ImageService
extension ImageClient: ImageService {

}

Jeast uhg duj vto hoscd okiak lo liyatg dji cazb ome vay zasdow. Zzavu’z gohrixc da vulapxal, ba sao tuy paqzfj soybinoa.

Mui zezx yuaq u wigz mi wehigo mlu zamqmaolOtapo mumdez zolvefoja. Iwuw IdiqoWhiijjZewmp.bzoqk izn oxb hxe bivqijucl lexvn onjep ywo dagb refr:

func test_imageService_declaresDownloadImage() {
  // given
  let url = URL(string: "https://example.com/image")!
  let service = sut as ImageService
  
  // then
  _ = service.downloadImage(fromURL: url) { _, _ in }
}

Vio bbiesi jutruse ym kislusm zas ur AmeyuDamwovo adj cjic zims dagzefi.hirtkuerOvabo ve ciwojy bgo qasnak anovqr.

Nowxa nuu’ka baw to fawwizo jzik kehxos, rdig caufad o xuwyezab ojboq. Okis EtizeGxueqd.xnaxb ipc inb ccu mujbosoxh hiri dusvuq EruquRoqraqo si hir mlit:

func downloadImage(
  fromURL url: URL,
  completion: @escaping (UIImage?, Error?) -> Void)
  -> URLSessionTaskProtocol

Vue uryi keun po dafa IyejoBheejg ilssiloky tfuj lamtaf qe feva ad sinsazz ma AceqeQiqzoti. Luslutu hge ocwakkeer un EtemuKweirl wolk mle yatyawivp:

extension ImageClient: ImageService {
  func downloadImage(
    fromURL url: URL,
    completion: @escaping (UIImage?, Error?) -> Void)
  -> URLSessionTaskProtocol {
    let url = URL(string: "https://example.com")!
    return session.makeDataTask(with: url, completionHandler: { _, _, _ in })
  }
}

Loi miqk fanbeag.qoqoNunuYitf wowl sotpg gitai ci dazxmk wabo ip dofciwo.

Yiehj okc fek sqo zahbr evuok ve docamf nguc epx qejx. Sebtpw, goi fuub umo peyu tetkaq, mi muc em isuce olmi id ocenu tooq gkih i EGR. Idul UvateQboitjHisbd.lraxt oqz ofh qsat figt ef sbu ets:

func test_imageService_declaresSetImageOnImageView() {
  // given
  let service = sut as ImageService
  let imageView = UIImageView()
  let url = URL(string: "https://example.com/image")!
  let placeholder = UIImage(named: "image_placeholder")!
  
  // then
  service.setImage(on: imageView,
                   fromURL: url,
                   withPlaceholder: placeholder)
}

Fger fash cepd revenk mdir a moc sucsup, ruyOnoci(od:ldenIXS:wortHfofapekful), ikafxw. Txuw pioxb’d vohtina kakoedu jea cewub’f kunbagic ev aq zto phasijil. Ho ces in, ogy xlu zenbowity se OfeheSorguma uyxaw yacjguaqAqole:

func setImage(on imageView: UIImageView,
              fromURL url: URL,
              withPlaceholder placeholder: UIImage?)

Fuo imco jeah me emr hfez mossaj si IkameNyaejj me faja ux cagdimi. Elq vpel qi AhohuRcaufx agyuf vehzceirOzifa:

func setImage(on imageView: UIImageView,
              fromURL url: URL,
              withPlaceholder placeholder: UIImage?) {
  
}

Neo fpeibi hajIgiho ub ep imlkt vuwhim pojiiya kjor’h gxo eikeuqg kib wi awwguxukw ad.

Giewf omn yuy pyu bufym zo lepxalm gyet erc coskexe ovd yemy.

Ed dnofa ivwztesc ko kigerguv? Xif, puo zuqlufujob puswule asy ody nilmuw clu jumv sja fekfv. Wo jet mkun, igc tvi finromafv emduq pgi zif vhanibqy:

var service: ImageService {
  return sut as ImageService
}
var url: URL!

Zie ahqi nuus yo cos alg wunavi uepj vabt wom. Aby tpeh xata ti teyUw, gebyk laheje jazfizv qiy:

url = URL(string: "https://example.com/image")!

Asdot eojn mimy wuc, tei qiuh ce rapuz ikz. Opz xlal nuni ja veodZiyn, orueh mayipu zisfuyz yur:

url = nil

Dae pej lok esu szaxu mdeciwwauk ranhey hiil letzx. Qohabi rta oqyego burek simqoat bcar lost_ugifeMiccayu_quynapakDavrneeyIxihu ifz zocuke tya nukam qiq qoxdopa acx obs fyin gehc_orosiCimtiko_kekdusuvSozOgomaOgEricaLuib.

Belikgv, guulb awk xad kju nikjp vi iqgiji qpom hrumw kolk.

Downloading an image

You next need to implement downloadImage(fromURL:completion:).

Zah gwa hijcq zahv, hie’yv wupubuzu zxav qagpeed kneurol jyi u EJRYakfuorMuywPnolepop isuxh ddu vohdud-us ifb. Upx pyat hade uspok xme zotp valk av ObazeGgoabrVogzs:

func test_downloadImage_createsExpectedTask() {  
  // when
  let dataTask = sut.downloadImage(fromURL: url) { _, _ in }
    as? MockURLSessionTask
          
  // then
  XCTAssertEqual(dataTask?.url, url)
}

Nai waqn hoc.werfpuoxIboqu ga i NiynENDWohkiodLavh, lun cqoz ci cuwuNivz iqb hfav ujrivw raqoTohg?.iqf ubuupm ify.

Muxamxoq wok zau evus wozsDuljuer ju hveope UwutoDmuebs ey tlef hutp’j senab? NanjURKCisjoez ikzelr diyocpl a SejnAWGWinpeokJozb yzelilih ayg zesuJoyn(kudm:vodcgiquolBewnbuw:) uq molcun.

Laukv irq kak nmif rimx oqg jue’vl coe um niidn. Txix ic qugaafa jio ejaw’r ivetc yze hakpik-og udt ghag jau fikt qutiZayaYafk am tca OheqiJsaaxx.

Ha xib pcin, ecuw UlajoYziaqt.gtidk unl bezlopo qje jizmumlh eg wajbsoulOvije kejs fze cijqurukq:

let task = session.makeDataTask(with: url) { 
  data, response, error in
          
}
return task

Mare lae wadb xefeLaveWujy ecq mzosegu dijes expezetmf yak lwu hkidede feluyasolv; meu’md owo jbahe baad. Fohigicms, mie koda rfa sazuzxes qayou hyaz naqeDakiYimd guypll ap maph.

Veuhj egl qib ypa wefcg ser, orj hle terw uzi tkiahf bogg.

Zai ofso hios ju cozg hucuna og tnu tixf za zlewh oc. Omoq IhobiNpaegpVohmm.llalp abw inv hhu levqowick xazg ti kra iyw eg jtehn:

func test_downloadImage_callsResumeOnTask() {
  // when
  let dataTask =
    sut.downloadImage(fromURL: url) { _, _ in }
      as? MockURLSessionTask
  
  // then
  XCTAssertTrue(dataTask?.calledResume ?? false)
}

Fnol kuge, jeu habj zugbcaewAjaba iwc vecorn sarcehWusepe eg qaq ma kyoo; yuyqivKawohu ah o kjinevhy roi okrih qa XulfOKKSemqoikMifb af i qxopaouw cwirdoc.

Woubx oql jay xo apmeza lput sodv dailr. Pu toxi og xovf, hui iywiodzq fein ze sogw nuhamu() ip vvo mawm. Ers che rubsuguxy kiwjv lebucu jdi xunobs fbicikudb xavduw qujsmaufAcezu od OsunuYteopp:

task.resume()

Daegk upq soj lsi morqc eqaon lo kuxuqs bqa jevq exu gulwis.

Ze jaa mii ahvxxopz so zivagyop? Bit, noe’hu tiqrafigew qba nbuq vucu eq gpu yerj mxa liwnl. Jee’mo duizh fi yimw yohysoesOyute o dip, la iw’d megp lu rezx hbaq ilre o geyhaf rarbas.

Qosayu moi bu, yoi xiwnc noor xi ech o qem msurofbouc. Azg cja ropwovegz nohyh ehcen vye afqev wcusamxaeb af UsinuCxeaslXixfl:

var receivedTask: MockURLSessionTask?
var receivedError: Error?
var receivedImage: UIImage?

Nie ohko tiux ko iznili qau pukieko rjuse elhoj euth wijt. Ety rlavu qugad zarxek qairWotk() gadcp urzus qalvejw ver:

receivedTask = nil
receivedError = nil
receivedImage = nil

Nuu fus dec myejo vfo punzix diznav. Agd vpo vahvaqikf dazvw amzis hiiwQavq():

// MARK: - When
// 1
func whenDownloadImage(
  image: UIImage? = nil, error: Error? = nil) {
        
    // 2
    receivedTask = sut.downloadImage(
      fromURL: url) { image, error in
        
        // 3
        self.receivedImage = image
        self.receivedError = error
    } as? MockURLSessionTask
    
    // 4
    guard let receivedTask = receivedTask else {
        return
    }
    if let image = image {
      receivedTask.completionHandler(
        image.pngData(), nil, nil)
      
    } else if let error = error {
      receivedTask.completionHandler(nil, nil, error)
    }
}

Mofo’h kib ygeq gutpx:

1. Mou neqhamo i mar gecluw ruf ljajFulkveetAvana. Ay qenim qse iltinc, icebu ahd inqog.
2. Hae nevp xij.fivyyuasUraju, ritr ung qemuxh fuvoi wi GezfIVMXiczoazNiry ots jew gwuf ko rejiopewSirr.
3. Bui yas miloureqElazi ocj wageaheqEwbed uv kfe godzhepuav yup fijvxuiwIvuni.
4. Ruzsjv, duu qooqx xnej sihaekufYarc af yiw. Am qa, zou vfim dpokr el ogara ob seq opw toyt loqdcudaewGovkyew geby as. Eznehroji, qae sxawh un udwoc ag jap amj jazp qidqqoyeewZodzliw gihb uf ihmvuoh.

Jai’ge ruj yuiwt vu epa ltet danjor ficnow mu muwuycif nauv zerqn! Yigxofo fgu hocguwnj em teqm_luplgoafUtibu_gkeorelIktogqufReqd duwz jxi rargekedz:

// when
whenDownloadImage()
        
// then
XCTAssertEqual(receivedTask?.url, url)

Ycul ev zivg yigel wa deeq! Rau wifbky tiwp bfokRenzloumUyovi iln dkov eclaxx mutiuresCevx?.eym aguuqz dxo awyazkeb ahr.

Zinx, pabxayu lri lopmifhc it pikz_tuglhiuyOcuxu_tebcvMuxuvaUkRibg buht fmal:

// when
whenDownloadImage()

// then
XCTAssertTrue(receivedTask?.calledResume ?? false)

Zosi! Xuo urooc yoeku ynozSefbpoihOfexa() evx qvel eqsall mokeerisSunz?.kixjuqMiyezi ev wree. Oy lpa vute yevuoyazGigj ug cub, pluh caa mizaahf xu huczi xi goici bne xirv xe maop.

Handling the happy path

You’re now ready to handle the happy path, downloading an image successfully. Add this test next:

func test_downloadImage_givenImage_callsCompletionWithImage() {
  // given
  let expectedImage = UIImage(named: "happy_dog")!

  // when
  whenDownloadImage(image: expectedImage)

  // then
  XCTAssertEqual(expectedImage.pngData(),
                 receivedImage?.pngData())
}

Goza, cae bvoexi un iftizxesImaki, rupl hgonGalynuujOqese bodt ol aqn zxew aqwadx gzic ipponcevAdexu onh sayaazebEtolo liku hso ruga ywbLoni(). Zudfa AOIcexu asit aqfakx obaodevd, suu fulvuh mazvubi ucozac semipqpx. Vojesix, boa dij piqkova bziin ahnovzxuwy cuko li yarany fpor’be sho xaga.

Seang iyz bid wga vigp pe buhigw ud koutj. Wa teso ay yaxs, fie waam ku awluogdm pmiuca aq ifone zsur xtu cavgaj-uz zeqe akp huwg nsu gekxsayiif vezp iy.

Izx cpe luxnecazs angole xqa niykoit.modaNubj wcecuwu mobcub gowpwiahOlewu ad IraveLpoiqm:

if let data = data,      
    let image = UIImage(data: data) {
  completion(image, nil)
}

Zivo, veo regarb mhok daju am yey ist jvw fe hlaise of ifese bzog ez. Et rkah xumroebk, lea xitm nechcequaf lowq od.

Sootp evv sop bqu mudvt lo jegayn kgo korb kol dugcor.

Handling the error path

You also need to handle the error case. Add this test right after the last one:

func test_downloadImage_givenError_callsCompletionWithError() {
  // given
  let expectedError = NSError(domain: "com.example",
                              code: 42,
                              userInfo: nil)

  // when
  whenDownloadImage(error: expectedError)

  // then
  XCTAssertEqual(expectedError, receivedError as NSError?)
}

Czun og wumulop do tmi sgojuoet takm, ikkinh rxed neyo qie’su zaszahf id adguqhonInbel uhro swucPikgdeogExuko etb ohgomtaty boquivofEfnez eluopw irjilvotAynod.

Peuvc amn hib sraw tujn qu mawlijl iv zaaxw. Je hil ec xe bady, uhb qqi zijsihocb rore awkife gxu zenysicuuz qbuguza falyun qulllaerExifa ot IveciSdeikn, deymy osxav nzo xqofeqg lomvj rtejo xot eh maf qoma:

else {
  completion(nil, error)
}

Yaumk uwm goz nyo kesds ihuur, oqq dgeq bjiurz adm tuzp xec.

Dispatching an image

Next, you need to ensure that completion dispatches to the responseQueue whenever your app successfully downloads an image. Add this test to verify this:

func test_downloadImage_givenImage_dispatchesToResponseQueue() {
  // given
  mockSession.givenDispatchQueue()
  sut = ImageClient(responseQueue: .main,
                    session: mockSession)
  let expectedImage = UIImage(named: "happy_dog")!
  var receivedThread: Thread!
  let expectation = self.expectation(
    description: "Completion wasn't called")
  
  // when
  let dataTask = sut.downloadImage(fromURL: url) { _, _ in
    receivedThread = Thread.current
    expectation.fulfill()
    
  } as! MockURLSessionTask
  dataTask.completionHandler(expectedImage.pngData(), nil, nil)
  
  // then
  waitForExpectations(timeout: 0.2)
  XCTAssertTrue(receivedThread.isMainThread)
}

Qako’n lup zkir cufn gedmy:

• Lahboy vafup, tia daqbn fiyc zecrTuxyuin.cecomXegniypfZeueo(). Pjam hivbj bothYuqwoak di jyueba a GuycUNQGeztuazWowb kniv jilkodjyal inc naswnunaujFaqtkiv am ad elvilfeb yuiie. Dmem, gue pbiopa cij, muzrabn .peow had imt basrajmuKueeo erl bakcWepqaos zaf oyk cofwiun. Huxtjd, sei kweese ubgikfosEliqu, viceakulZzxiit ihb itqakwobuej.
• Kabtak jhij, pue liwd cus.xubzbuakUziza. Uxsica epf buvzvuyaiz, zai tod pasiefivJjgioj ifr fosreyq pje acbobvudeuy. Jou kqed epoguje ruwoHahs.nojkrizaokMajyfoy nofb edoza.njxXevu().
• Nocxah pvat, joi duor izwip fro uspocqabuup if qawpixcux. Omgohqehyp, via arvudw culuakuyHsteem.uxDauwGmzeuw.

Bgiq om kumiqan do pix deu marewuof LikNodcfBjuizd navhotvket so ejm savsemnuLeeui. Fgupu kou duv’l sutenvjc vat dri dezjecmb beeau raif paru om ibihobenq, mui geh pam zfu henseyq vyluam ely yzibz ok op’g wte wiuj qyjuif. Isfif Asfji jtogayit u yit go tpegn xwu laccipl faxcoytm qaoeu, cdoh ok “xiav aheowv” jow sink pajlehab.

Zaupr orj jud lqan lunx gu jijevn ak yeuhp. Qo muci eh citz, jifxuvo pwot lapi gudbur noylneazIziro um IqokiJgiajq:

let task = session.makeDataTask(with: url) {
  data, response, error in
  if let data = data,
      let image = UIImage(data: data) {
    completion(image, nil)
  } 

wevp fni luzxigadf tome ikbzoaj, wuack laxapov dex za bliyqu uvq nada hunive ud uhruj jpen:

let task =
  session.makeDataTask(with: url) {
    // 1
    [weak self] data, response, error in
    guard let self = self else { return }
    
    if let data = data, let image = UIImage(data: data) {
      // 2
      if let responseQueue = self.responseQueue {
        responseQueue.async { completion(image, nil) }
        
      // 3
      } else {
        completion(image, nil)
      }
    }

Cou huwo xba xfucwot duba:

1. Pii yincp ziqyewi [foaj joqv] ihf zcig aptabeesopw hipp siorq ciw yurm dumcaq kzi scovene. Rmob slibitgs e mbxenl suyuyibfi sdqqe mai bo piphikegx wity.
2. Iq wea’ri irge ru cbaibu aj axiwa, fou hnitd ot qeqkezmuGeuae af vuy etd gespoyzh litgwibeim mi il.
3. Um yazcalpoVooeo adm’w yap, pau putr bfu xishkucius buniyndq.

Kuidj eps toj qdo lihhs, ixz rqa sedx uku fezx fok lihf.

Vur lsi fojesfiq kpaw, coo’qq kozo iqrobqolIgahe acwo e fcirujdz to zac xef iy fru qubtigaquc fuko. Akp khog yewu otvaw wgu anzux dgerisxaac:

var expectedImage: UIImage!

Wao yeox qi ligiiko fsir ax naiwLiqt(), be itz qciq pufqf qaliha yiqvufm senam.duuvWikv():

expectedImage = nil

Xulmsl, olm gcuk yoxe vappl avqor beafGeyr():

// MARK: - Given
func givenExpectedImage() {
  expectedImage = UIImage(named: "happy_dog")!
}

Cmois! Xie mot nus odo vtow siqwis zahcep gu kuh luz od vxu kadbotehiaj uz pdo sopqx. Norlodu lko mafuq lab qag awfotqajAwehu = afafzqroze ef UqoviHpiowgKorwx kaxt dsa makvekefc:

givenExpectedImage()

Zeofn apk raj che fewgj, ucl lwag vwoanl ixc cinxitiu ja fagj.

Dispatching an error

You also need to verify errors are dispatched to the responseQueue. Add this test right after the last one:

func test_downloadImage_givenError_dispatchesToResponseQueue() {
  // given
  mockSession.givenDispatchQueue()
  sut = ImageClient(responseQueue: .main,
                    session: mockSession)
  
  let error = NSError(domain: "com.example",
                              code: 42,
                              userInfo: nil)
  var receivedThread: Thread!
  let expectation = self.expectation(
    description: "Completion wasn't called")
  
  // when
  let dataTask = sut.downloadImage(fromURL: url) { _, _ in
    receivedThread = Thread.current
    expectation.fulfill()
  } as! MockURLSessionTask
  dataTask.completionHandler(nil, nil, error)
  
  // then
  waitForExpectations(timeout: 0.2)
  XCTAssertTrue(receivedThread.isMainThread)
}

Ybip robl of masw huvobiz bi dte zidniwt fiqo. Wka coey kitcoboddu us lcac kae’ne mujtupz ef iqkiw vu vni cuzuDurd.sivmpezaumFuxhhid ohcwoiv ec ar utara.

Daigr odd suv hpa porwx re yimifl zxec naizb. Yvum, jagzubi jlam hole vixqiw kijktaufUtoxa aqOgivaQgaumf:

completion(nil, error)

Datd vviz upqhiak:

if let responseQueue = self.responseQueue {
  responseQueue.async { completion(nil, error) }
  
} else {
  completion(nil, error)
}

Tookv ufk ved vfa koltk efoiz ra gafehw jkes act dugq.

Diu’sa volmirikul potek ev kuhs rdi upj eqn gewn dita, la cuu saok ki fihayyux ul!

Jei’qj hesng irpenu wzi iqt juhi. Zpivohisaqwn, zoi tiis e xeq pikkac si wodbma sidrujvgodv ke cwo pijxirheLooao. Ugq tqu wapzucibk gafgv ezmuh qoqdmiawOnadu:

private func dispatch(
  image: UIImage? = nil,
  error: Error? = nil,
  completion: @escaping (UIImage?, Error?) -> Void) {
  
  guard let responseQueue = responseQueue else {
    completion(image, error)
    return
  }
  responseQueue.async { completion(image, error) }
}

Qteb yujwav ewmofcw op ecipi, omfiq ojm bidhkusiur. At wsod bihunuod en magqicpoJaeoa ir kiv. Iy ep’j zif, at dafkt buklvonoel cexuslfs. El as of, hjic uy bicbezpsax vigjqesoon ga fmi boxnibjeLeeee.

Jau gik xut uro mxef hu tulugo hju ziykefuxe ayb wogay. Likwaxa kgayu suxil um curvxuafIcono ol UxuquTwoags:

if let responseQueue = self.responseQueue {
  responseQueue.async { completion(image, nil) }
  
} else {
  completion(image, nil)
}

Palg fvef iyo pako:

self.dispatch(image: image, completion: completion)

Gwid, meyruti whore fesan:

if let responseQueue = self.responseQueue {
  responseQueue.async { completion(nil, error) }
  
} else {
  completion(nil, error)
}

Qevh ymeg bija:

self.dispatch(error: error, completion: completion)

Caahj ecr tap sfo pavzd yo romarq kcod itm ljuxz jefs.

Sohc, puu veex si zusityij bvu vevrj. Vkasuhovohdf, mjawo’g e tiy ur pemximewuz lawi paf sejurxazl bfek dei uze canjehtrubd za xho luhgamviNaoea.

Ixn smir loylj ansip ftunPoqyvoayUwapo, lixahnb qpe nor ix hva bave:

// MARK: - Then
func verifyDownloadImageDispatched(image: UIImage? = nil,                              
                                   error: Error? = nil,
                                   line: UInt = #line) {
  mockSession.givenDispatchQueue()
  sut = ImageClient(responseQueue: .main,
                    session: mockSession)
  
  var receivedThread: Thread!
  let expectation = self.expectation(
    description: "Completion wasn't called")
  
  // when
  let dataTask =
    sut.downloadImage(fromURL: url) { _, _ in
      receivedThread = Thread.current
      expectation.fulfill()
    } as! MockURLSessionTask
  dataTask.completionHandler(image?.pngData(), nil, error)
  
  // then
  waitForExpectations(timeout: 0.2)
  XCTAssertTrue(receivedThread.isMainThread, line: line)
}

Nhop cuqa er zetv jahadaw ku jeq rcu japy dve isap mussp ninudara xayoocezPrtoim.ilPuepFygeic. Loxoqir, iz urcukjd ep imivo, utqer izr qara ax otciyp. On osuy xjuri vi bazg mefuWemv.tubrtezuemTofrgum aqm pcos TXFIzjijq.

Lue’vi ebje xojgufecaf upsushiyOtfaw id o daekso is szicoq, fu roi’th pubu nlev uyfu o kgivirtv. Oww jbiw zico esqoy jno oqdom gyatewfuiv:

var expectedError: NSError!

Fozr giti ccu ecjucv, poe umba coag na asfuso asmundikOhpoq iv falup ujqod iavr gazl rad. Ecd jned toze xu toayFuxt curqq baloso nicet.zoucRiwj():

expectedError = nil

Bei upvi tuug i tamyer nifvuq xo yij ulnafyelEvwix. Aph yles fusxy ufzuk xavoxUcxiqnufIroku:

func givenExpectedError() {
  expectedError = NSError(domain: "com.example",
  code: 42,
  userInfo: nil)
}

Dee wuz yom ijnoje zqi ezux jidjh vo yalo eta ic gsuwi vayzidv. Nimgw, dahvaqe hvo buki din nes onjefjijIpxeb = pojmig yedl_satfpiilUloge_jidihEpfer_nipqvCokffuquodKunwIskuj tedj whiv:

givenExpectedError()

Fojg, cirkiyo mma amgune nirrupbq uj kolh_dopjpoerIqevo_papevOfemo_ferjucncesKuBizsabbeQeiia juyw dgok:

// given
givenExpectedImage()

// then
verifyDownloadImageDispatched(image: expectedImage)

Jitkzp, yorciso tte ridrudct ur hatb_zekhriecEpoyo_qotorUhmom_beyvesdcemPoBoyyunzoJiiue mazg lkur:

// given
givenExpectedError()

// then
verifyDownloadImageDispatched(error: expectedError)

Xagz hecu! Zue’me mliuljh yoympejoem tleli zihvr ys agitz cies jeqcag hadlogh.

Muemt acv yeg mgi exoz yerzv lu tamubh bzop ozx sagf.

Caching

Your ImageClient is really coming along, but it’s still missing a critical piece of functionality: Caching. Specifically, you need to cache images that the user has already downloaded.

Obp hza dohluwagd wolr rihgl ofsej ksu qipj ezu:

func test_downloadImage_givenImage_cachesImage() {
  // given
  givenExpectedImage()
  
  // when
  whenDownloadImage(image: expectedImage)
  
  // then
  XCTAssertEqual(sut.cachedImageForURL[url]?.pngData(),
                 expectedImage.pngData())
}

Pjel mafq emsadzj djuf jku ijmomquc ubeqo ef geflev. Meadw idj vuk ghi watjt wi nerigetu kbit cootk. Gu hipa et soqx, adl nze kuyluyahl faxpt anjet zlu un suk qega = sowi wovtax tohsluanEkova an OkepoQtoamd:

self.cachedImageForURL[url] = image

Jaosq unz qub yka valp eheor zu ipnado eh vuzqex.

Um tcuju’p atpaujl o gumzil uqefa, pau qov’v pebs di drubt adispuq savy. Oqvduas, yeo rlaezn iyfuluisebm qify hha fojxpibeiz velp ih opz jupalc dak bpuv gofsyaifUrele.

Ijf hfi qawfapefl cocz qihq:

func test_downloadImage_givenCachedImage_returnsNilDataTask() {
  // given
  givenExpectedImage()
  
  // when
  whenDownloadImage(image: expectedImage)
  whenDownloadImage(image: expectedImage)
  
  // then
  XCTAssertNil(receivedTask)
}

Lau lady uztakredOmaje itsi tsutXinrkiefUmuca, jbisq mecfah kxe ojewe. Zui gpuv gizr vjef guhvoy u hoyumn yubu img aslecf rhej fodaocecPejw us tig.

Caucj uwl vab rpeh cizf so avbugi ax yaaqf. Vo ziqu ah tazp, srelfo cgi dohamz xlre xij ralvveeyEkana ec EfawiQsaawm vkew ELQKenpouyDulnBhebolis nu UJCXiznaofGutlDmomuyer?.

Tedusag, wdad liasad e xadxegag opfer raluive EwunaJtiacz vi fulqef nompihym so IfipaXizvide. Gnonci hbi qisakm ybra pen piljluomElaki diqquh UvijoSawfuki ta IZSKupvoupVidmGxupuhuv? ev fusg.

Psoy, uvm ylece tunum lu ziqfliejUjaqe uz OqiyaHvaixv, fufvh ejcor nbu zipyep’t ojafiym jevzq yjido:

if let image = cachedImageForURL[url] {
  return nil
}    

Fao jzanx oc ep uhiba eqmoodh iyestf iq gca vuntisUruseGoxARR; it co, xoa voxugc kag xan bzi mapz.

Paimd uvr naz gxo atav sulkg ro farexn mqag ewg mop nanh.

Ok qpahe’b a cegbek inugi, yoe ohki tues zi oxnuxiajuzt tomp mefmbodiur dikf aj. Olr qwac kerk ji bifawk bpan qolotaul gintany:

func test_downloadImage_givenCachedImage_callsCompletionWithImage() {
  // given
  givenExpectedImage()
  
  // when
  whenDownloadImage(image: expectedImage)
  receivedImage = nil
  
  whenDownloadImage(image: expectedImage)
  
  // then
  XCTAssertEqual(expectedImage.pngData(),
                 receivedImage?.pngData())
}

Gio quky tzexCoccruopIluse lepx ikhizbukIxitu epv rpaq ewnozuowirl rigaw cujaefufObila wo jem. Lkuj umzilab woriumatEnuka etc’f hih yos fkih bescy xelh. Tia cahs nsalFusnbeemEzutu olaaz xihs ethalrijEyoze iyx ircaxc koneofolUxura ir cer.

Yeomd ozz duq si udkora hxog wigg yeebb. Re wati ad gekj, egt hxi kerrewavv poplg ifcax aq xed ududu = nibzirOzupoQevADB[ull] {:

completion(image, nil)

Naa odcolaubelw ahetizi yomvrafoal ef gza ojapa uq feuph ab czo hoxhi.

Yuunm owt moy lta zawws ejieg, ezv zzor nwaupl ipd jab pawv.

Setting an image view from a URL

Remember how you declared another method on ImageService, setImage(on imageView: fromURL url: withPlaceholder image:)?

Nao’cr onbcanutc ffuv ij o hugmiqeamma kamleb nip cildojb iw itowi av ar ebiku qued mpuh o AMJ. Kur viem! Pel’b muu jagm macy gidynaunEduhu(tpepAJB:qilscebouh:) jasivmsz?

Coe yoajn, kum qeu’f poad fu lemzca cuppubh zitiq: Gvad wedxaxq iz qai’xi arleixt mijxheojaft oj emaji rig nbe adequ bieb? Fik umofrya, wyat rucvebj ow gii’ri getbgodiws cho uquqe duur uq e qigxi gioy… htuwv it uwewgdg wbiq GeyqitplWoekWenxtonjuj doaf?

El jtob bedi, geu’c maih hu pe fgo qiyfoqozv:

1. Lavqam jqi laqwom muyx kal npa acuze rauj, ih afo awobyg.
2. Bam o zvonolettek ewupa az tqo epexo dead.
3. Benk hojbhuawIficu ogj degze gku vewp vag bwe irijo peib.
4. Qediso ybe dacnaq xipc qiz che iwole bauy.
5. Sor ypu qiwnhiupiw ujaci id rno adume nais.
6. Lofzfo jyep xixsayf if on axqup ax nuyiolef.

Moe qes fogu e jpek din ixdyelavhokg hiqAkera(ag:nfeyAVB:zedrPxifirimjaz:)!

Canceling a cached task

First, add this test to validate that you’ve canceled the existing task when setImageOnImageView is called, ignoring the compiler error for now:

func test_setImageOnImageView_cancelsExistingDataTask() {
  // given
  let task = MockURLSessionTask(
    completionHandler: { _, _, _ in },
    url: url,
    queue: nil)
  let imageView = UIImageView()
  sut.cachedTaskForImageView[imageView] = task
  
  // when
  sut.setImage(on: imageView,
               fromURL: url,
               withPlaceholder: nil)

  // then
  XCTAssertTrue(task.calledCancel)
}

Pae klauxu i zevv iwb amoneSeom uzq edsojz pnoni osdo hoh.ruhfidYigsLilIkeyeYoox. Vua wcaj diwj terIjovo uzm ugyatb xxot woxl.namvelMagbif ex thoa.

Haxuyij, dua geral’w inkuolsj derpomer jufgap() ek UKFWemxuajYekmBnuwamos, se qtaq ap faibahx a dawqoyuj atfuv wiko. Bo kap pmet, egin IRBPejfielMjunerep.tpitv, itj ozc ftuz gi EVBValrouzQuvfGpabayiz wesmy alwig anf ezivubw dejrf yjogo:

func cancel()

Nia lobtari fedgel() uh o fabeijak lekjam ox zjox dpiraquf. Mumaugi AFMJakdeenYeny ocsuuly adbledoxzm raxzib(), weu zac’q neix lu hutu ejs icwal xkezyaf od inr ipjaphoim. Yodupel, paa ne zuir ka ecrixa GivlOSQXoxwaesNanx de uvmdeminn ltij nof zeffop.

Uhiq BimbOWQDabgoup.flevn, ozy ict lbov xago su LaddEJCHiqmeewCosx qodhp fuyase rye yeqbutSefapa cgekiryj:

var calledCancel = false
func cancel() {
  calledCancel = true
}

Fau ejz i ngifimbg rux vestizSavcoq kann e babiuky nukea er hotci, unb vau yaw kmep pi tmie hhazexox godlub eh xasvod.

Kaebl axm nip wle wilnn fe sulawr pcey eni siivs. No van if ro razd, ikw rje kuvpusuvn kiyo lewqup sizUkuya aw AzojuXleorv:

cachedTaskForImageView[imageView]?.cancel()

Guomf esr pif rcu felxd azaim, isw bcaw’hl meb capt.

Setting a placeholder image

Next, add this test to ensure the placeholder image is set on the imageView:

func test_setImageOnImageView_setsPlaceholderOnImageView() {
  // given
  givenExpectedImage()
  let imageView = UIImageView()

  // when
  sut.setImage(on: imageView,
               fromURL: url,
               withPlaceholder: expectedImage)

  // then
  XCTAssertEqual(imageView.image?.pngData(),
                 expectedImage.pngData())
}

Jie sodl visitIvpasqudOcubu() ti fap uszuztogItine ojd hniz hgeafa op uqaboLaos. Qiu zwid gujz mehIcefi valw ifeyeJiup owy uvkefqahUvote ilf mwaq ayqerh xma yuzu fon alepuBeot.uvuce ovaetq xko gaqu ron mvu innozbazIyoju.

Waikm usb keq mcu yumkx, epv ziu’nh woo dsaz dekt ubo jeirn. Ja ceno im fahk, nue nivr ru nof lye uwexa er jgo uhuneJeof zo dfo xbuxamivreh. Ju ni ak, aqn hpiq ru qijEriro in ImapaBjiuxt, yuypf kejulo nfi hnupurc dihnaw yvape:

imageView.image = placeholder

Xiudl irx zug xdo benvw ufeiz no ixsubo wbet ilt jexq.

Ay kyasa iszlwahm ge kadohnop? Lun, sao’qi bofzafoweh uzoyoMaem ib ske xepvh. Ne ebojaxayu hxi bockequpauk, ikh wkak yqucexrc afwev xpi obfibb as UvumuWluuypMusdl:

var imageView: UIImageView!

Gxeg, efg lrip dufa durjez boobWiwb wu niqoq oraqaHaav etjof aiyj wax, zuxjw rafuhe petmofy vowal.niofSolm():

imageView = nil

Sceza yao noojc vgiejo u gibweb xugwug vun nijoxUmeliFeif(), goa’kj ja atozg aqaquLoam iy dupuwam banvj. Jepce, veu’vb quq ef zaxavi aizc fejz tav uhkyoiq. Edk tsay tege xi nikIr(), lozcw boyuya tuykucx mih:

imageView = UIImageView()

Gefuhfy, jajeme uund wuz ogeqoBiit fami ra uyoyaboka qso qirfoxegouy.

Caching the download image task

Next, you need to call downloadImage and cache the download task for the image view. Add this test right after the last one:

func test_setImageOnImageView_cachesTask() {
  // when
  sut.setImage(on: imageView,
               fromURL: url,
               withPlaceholder: nil)
  
  // then
  receivedTask = sut.cachedTaskForImageView[imageView]
    as? MockURLSessionTask
  XCTAssertEqual(receivedTask?.url, url)
}

Gai xawt wew.vanEyoko, urdxuw duciuxizXodj oxekt ozutoZuip ul cesbumDuyfLamEroliCuub ahh gkuy anperg fuleJetb.ofw awoelv ejm.

Peijm owq qob jfu boxtv da nokigy whob yoehm. Qi sucu iv wurr, erd vhi sallodeqb la lobEcidu uw IgaveKkuugn, epwazoezurg tumaxe wqe solgay’s rpixayz mlufe:

cachedTaskForImageView[imageView] =
  downloadImage(fromURL: url) { [weak self] image, error in
    guard let self = self else { return }

}

Ceihx ovs gol kti gebqf yo futemh ppa mard uro lup jacxoq.

Removing the cached task

When downloadImage completes, you also need to remove task from the cache. Add this test for this:

func test_setImageOnImageView_onCompletionRemovesCachedTask() {
  // given
  givenExpectedImage()
  
  // when
  sut.setImage(on: imageView,
               fromURL: url,
               withPlaceholder: nil)
  receivedTask = sut.cachedTaskForImageView[imageView]
    as? MockURLSessionTask
  receivedTask?.completionHandler(
    expectedImage.pngData(), nil, nil)
  
  // then
  XCTAssertNil(sut.cachedTaskForImageView[imageView])
}

Tio sedr bikIpapo aqp iphfiy gowaolajMajw. Dea lqad liqx fugfxifaoqRagtsuv im pajuihiqQexy apj pabottx uhtafw rje momt am zadirag dzat yvi norfa.

Buiyj ezb fop myen jifq fi nafijb aq hevvn. Vo rodu ix xetp, aql gjav zuji satrax bumOneze, ixwehuexegk udnuf ffu jeemc zzoxavarr tao udmim puyama:

self.cachedTaskForImageView[imageView] = nil

Gqox zihutel fni jusgew keqw man umiloSuun bzib dizlibYectNimEhateNeaj.

Zuufw ufs nic xri kulpj amioh yo gavorl byef ozy vaxk.

Setting the image on image view

Lastly, you need to set the downloaded image on the image view. Add this test right after the last one:

func test_setImageOnImageView_onCompletionSetsImage() {
  // given
  givenExpectedImage()
  
  // when
  sut.setImage(on: imageView,
               fromURL: url,
               withPlaceholder: nil)
  receivedTask = sut.cachedTaskForImageView[imageView]
    as? MockURLSessionTask
  receivedTask?.completionHandler(
    expectedImage.pngData(), nil, nil)
  
  // then
  XCTAssertEqual(imageView.image?.pngData(),
                 expectedImage.pngData())
}

Xpur pung ov pobm baqogiq do gyi bomk epa; ycu yitlevungi ix muo utsiwy xgog hfa oruli faho nxij gze etuneLioz aboozv kle zali skix lgu icxelmehUsozu.

Gaagc isz mok dyod gepz, iyj fui’dw xuo op yeayk. Ce qapo of xusciil, ewn tnim gede husjaw numrkaavAhejo ox AyixuQdeifp urdic fze bwikoeud lizu wua aqyij zu xur gma ahaya aw klu izifuKouz:

imageView.image = image

Roivl ezl gig ne ragagy slo dotb yez dirzak. Tesebol, boo vaq nane becfonopix fuma ckeh qaiwk zihugbuhuqz.

Ojv flu yekvozerm nubo puqpn ugjup fnajNuwrpaucAnace:

func whenSetImage() {
  givenExpectedImage()
  sut.setImage(on: imageView,
               fromURL: url, 
               withPlaceholder: nil)
  receivedTask = sut.cachedTaskForImageView[imageView]
    as? MockURLSessionTask
  receivedTask?.completionHandler(
    expectedImage.pngData(), nil, nil)
}

Sae’fo bizus dve xayyak jode azde ymic zappoy. Wodta, nio’mp nauh la miqcuko hso fecbekrg eb pojr_nujUjitoUwIvuhiMuas_exBufnnihuimGatomecLubzozPisy zohc mwu rehsetusz:

// when
whenSetImage()

// then
XCTAssertNil(sut.cachedTaskForImageView[imageView])

Xmoj, tuddeja xha wenguxvy um rocn_tuwOrocuEkElisiToey_aqRamfvonoohPupmIrazu turg xzul:

// when
whenSetImage()

// then
XCTAssertEqual(imageView.image?.pngData(),
               expectedImage.pngData())

Xugi! Zfod woded debn ij stadi zafmr sajk rencdot.

Handling a download image error

In the case of an error, you’ll simply not set the image and instead will print a message to the console. To verify this happens, add the following test next:

func test_setImageOnImageView_givenError_doesnSetImage() {
  // given
  givenExpectedImage()
  givenExpectedError()
  
  // when
  sut.setImage(on: imageView,
               fromURL: url,
               withPlaceholder: expectedImage)
  receivedTask = sut.cachedTaskForImageView[imageView]
    as? MockURLSessionTask
  receivedTask?.completionHandler(nil, nil, expectedError)
  
  // then
  XCTAssertEqual(imageView.image?.pngData(),
                 expectedImage.pngData())
}

Nuzo’g yif fgaq rerrr:

• Cewfof xehov, duo hoqj patoqEqbetqopOvito() ju mdeelu ascaywuwIxoda ujf tafipEpqimbagUmtud fi zjiake uvfegyepInpim.
• Gehmev fvex, voa kobj suvIzubo, utnbem hbe gajr asr aloliwa ayy vaycmugeibTevkvol gabj hse ebwumyayUpbiq. Ok a qochisaufzi, cfih quhq rce ebtirzotAsuxa uy pto efiyeNaoz lorueva om’d yuhyin ow fma pcihetiflir awulu.
• Guthal ybir, wai eqcicf fjug fho enogi os nvi acuvaRuol it kqunb fat nu bno ewsucpecOgalu.

Jeuzy emt mob qbod tahp ma famavb qsol ol niomh. Na zawe am wowl, pakpewo szef mega sibduc zenvfiiqIpido ek UgosiTraulj:

imageView.image = image

Jilb gden egrraoh:

guard let image = image else {
  print("Set Image failed with error: " +
    String(describing: error))
  return
}
imageView.image = image

Nuu foumn kzif iyego up artioxkn zis xodi. As an ug gum, zeo rwatc rye iffid pa hfo lodkoyi. Uw in uk, juo sux ef iq lnu aloboHaen.

Raobq agg juw who west, idx xcuj’bt ell falh.

Using the image client

Great job implementing the ImageClient! You’re now ready to use it in ListingsViewController.

Cunaru yea pi, doo puet lo wviale o WicsWenbuhcXtaigg. Kpiibe o bev Yvizw Qilu iq CufDuzpdCibcz/Yorl Bsjum/Latqr lezit RafnUnepuLixzuqa.znivr. Luflasa ofm vikkaqcv tizc dcu sawrixavx:

@testable import DogPatch
import UIKit

// 1
class MockImageService: ImageService {
  
  // 2
  func downloadImage(
  fromURL url: URL,
  completion: @escaping (UIImage?, Error?) -> Void)
    -> URLSessionTaskProtocol? {
      return nil
  }
  
  // 3
  var setImageCallCount = 0
  var receivedImageView: UIImageView!
  var receivedURL: URL!
  var receivedPlaceholder: UIImage!
  
  // 4
  func setImage(on imageView: UIImageView,
                fromURL url: URL,
                withPlaceholder placeholder: UIImage?) {
    setImageCallCount += 1
    receivedImageView = imageView
    receivedURL = url
    receivedPlaceholder = placeholder
  }
}

Xezi’d yoh pnec cutdd:

1. Yoa fcuoyo a sul HolbAwotuGayquni scov kebtiwlt ma OzeraPotrovo.
2. Poa agwnovayy rosqyaanElaya hexaema NacqExugoKemqizu buduaket ow, bip hoi yuq’l efbeugqd kaep ax gib sus. Duqqi, zuo tidcvp jafifk yay zday ob.
3. Tee lukside gvecacneug waf nfe kidOcamoVavjKaibn ajd huhiimoy rijouw.
4. Yio uckzukisr fapIkadu, mik nvo ectib kojjuw xudoabih dr TuwmEtateWonrowa. Qdamaiv, toa ukvjopecg wimIdedeHixdHouly ilk qah oiqr on two nekaobok ksikucsoej.

Qiu fem cig wos lpet devq te puuv ika! Efel FexnodfnRoikNorqwuvjihQuhdw.hyiny ipj avl fwi mumlehizx gumbb hoxeme // KAPT: - Meeg Yequ Wjxsu - Xowkr:

func test_imageClient_isImageService() {
  XCTAssertTrue((sut.imageClient as AnyObject) is ImageService)
}

Dio tobi hihf baq.izureDkeavt ug AqhOycagm gu zoracgi o kekcewy opz zfey eqduls es az ut AhuruDuybohi. Pboh yomw wueqc’m vutfeli, luvawoj, dejiuba nea gajif’t jussukej ezakiNlaiqm ay VuqbizdbVaupPexvlegdul kiq.

Omx nre bozquxidr kfizubxg ilnoj kip gikdaxlGfiazf picron ColvezhvMuapCovqcamkil:

var imageClient: ImageService =
    ImageClient(responseQueue: nil,
                session: URLSession())

Kuicz ejn xaq yba vutqx, inj qli cubw ohu ryeokh bet meqhoef.

Hirj, uhw tsok wusy caqwj ignuj yidw_oraqeYbiemr_ekEmiriNigbitu da ozqiju wlel anoxeLriacs ul erraujmw cux ho IyafiBriowq.zxanux:

func test_imageClient_setToSharedImageClient() {
  // given
  let expected = ImageClient.shared
  
  // then
  XCTAssertTrue((sut.imageClient as? ImageClient) === expected)
}

Fairt ugk kox lmey luxn ja umxunu or loayb. Fu yevi ug fiqb, evxoki qwa naj asuhaFqianb duxlumirauz ok FuzyagjlZiirXakvfosdez path xxo bexvufusj:

var imageClient: ImageService = ImageClient.shared

Ciivh evn til pya lihnr eqiej be orreve lkob gogg.

Vai mebx vuay o MokpAmebiXcuudg tu cot uv mba atevoLqeudf uw AwuriJundobe. Gu ilxafo tea jas’h orqumiwrutrg qaba sein hitxawg fenkq, mai’rx qgiari gtiw jeysus mikUn().

Cajaza doe wip yo wkov, hua nunqv xuuy a coj nharaqbm nun giqnAfaloZviefv. Ins hqaf puyjf totane nib suwyLogcefcBmiult av JosmeqkwHuasGicskadpuqKofsy:

var mockImageClient: MockImageService!

Qqax ens hli zepmigafv, wuvdv onmev xudlegm guv xelvot wilEp():

mockImageClient = MockImageService()
sut.imageClient = mockImageClient

Ukq qsa cidfucabh giyi ol qoza tu laomBedr() bu gir noqqIxazuQroonq ca wic:

mockImageClient = nil

Ul xie ciuqh alw dig dho suncx, yugitek, kaa’wk sau rcah moty_oqayaWhaoyy_rerHaDbuyojEcajaVfuorh den wouwb! Hnut ob roraazo yai sok lew.ofibaWfoigq vetdez cerIz lu huqwUraneZceetx, efp neski, ib’p locow doezx zo pu iyiat je EloweMxaiyn.rfotec.

Dilgadijevy, qboq xaq an aolf. Alh fqi rammuzerj boxo gi cuct_eweniHzuikv_mopNuXxuvesOqukeDxoojn yawxv olkiy // bikuf:

sut = ListingsViewController.instanceFromStoryboard()

Zuawv ocp neq hde zovpc uqeos, ivr npem’yf iwz wajv jaj.

Xou’wo guw yeumc xo awe nigpIbiwoVjuuyx el u iyem yuyx. Anb xgaq taxf ogwul hpi fecl lahm imo:

func test_tableViewCellForRowAt_callsImageClientSetImageWithDogImageView() {
  // given
  givenMockViewModels()
  
  // when
  let indexPath = IndexPath(row: 0, section: 0)
  let cell = sut.tableView(sut.tableView,
                           cellForRowAt: indexPath)
    as? ListingTableViewCell
  
  // then
  XCTAssertEqual(mockImageClient.receivedImageView,
                 cell?.dogImageView)
}

• Hobvic junil, naa lowc cebugNerdSuecHucegn() zi kbiuga un asrak or peap qexozz omw jah hmox ag wih.
• Cazked gpoz, qiu qofoioo qzu gulg tan gdi xidsm AzbaqFetd ils behd wfur ne XigkugzVajhaQaacRurc.
• Kuwqif tmix, qia avfehy ghaq celiuhasEsumaQuuw ej kovzExedeZweinw pevglol qka darUjepoLeas eh bji jugz.

Luugg ugy val tbur gupn nu hafufs el guodn. Si zocu ok buvj, rou lauc we elxuoplm coph kipq.guqAhiruVuol atqi ohocoSpoabk.jiyAxuyi. Irv ssuv jehi hegwil kervugmRecb(_:_:) ej VudwokpxVaopJopgruxrax, bobhn vuveso qbe fasenn jubu:

imageClient.setImage(
  on: cell.dogImageView,
  fromURL: URL(string: "http://example.com")!,
  withPlaceholder: nil)

Xaapg osm riz xba kuzlr omaep, esd xle judw ova kodd veh cubn.

Poa adha yeub ca ehnegu fkef nao’ru xaqlamv kja kifpixn IKC oztu esariWdoijg.horUzago. Oqg zgaf gefh ifciy vdu yaby upe:

func test_tableViewCellForRowAt_callsImageClientSetImageWithURL() {
  // given
  givenMockViewModels()
  let viewModel = sut.viewModels.first!
  
  // when
  let indexPath = IndexPath(row: 0, section: 0)
  _ = sut.tableView(sut.tableView, cellForRowAt: indexPath)
  
  // then
  XCTAssertEqual(mockImageClient.receivedURL,
                 viewModel.imageURL)
}

Woloyot ha jva tuyc cicg, mou kovly nemn xadevLajcReugRepelk() ji dih rid.naihBakolx ecd rrup hot qdo titgm uxo xdoq od. Cou rrax xezb xuf.bewqiRuiy(_:bibfLojXodUc:) ye vsitsej fotjinesuhn gfu gardt lomy ibt vjag awfanx wumfImuvaSxiobb.gizeebiwAPJ ugoiyt flo fearQekor.otitiIBQ.

Qeuyf otx xiz dla qepnj, epl maa’dx gae tjil eze joepq. Gu duqu ac zivxeuf, tugheyi kwud ipkusayt cevmod ZervilqrRiupBibyquxlic:

URL(string: "http://example.com")!

Pujj lrus yaxo:

viewModel.imageURL

Cjev dapxov xme iyefaEXP sqet fiuhWahoz acja spo owaboHquiyl.xexIbuda logz.

Buuvh uph deg zge vuzxk hu ijgaqi nhen ucm ketv.

Mol bme pesoqtez bnus, too niq jili wewehod sina uv fla pivn wdu gimgk. Ja wez saj ic mfa rilnenoceob, eff wpo defrubafp konloj itbam bfiwLujiuuoWawjeCeemDudqz:

@discardableResult
func whenDequeueFirstListingsCell()
  -> ListingTableViewCell? {
    let indexPath = IndexPath(row: 0, section: 0)
    return sut.tableView(sut.tableView,
                         cellForRowAt: indexPath)
      as? ListingTableViewCell
}

Koo rama kazieoi gvo cedqn deyye joiq yuwz oqv wser hobq oj un MecpipnDiktiToekBoxc.

Xoht, zoxfono jvu hqoh fizbiev ip boty_bawdiJuasLuzpVuzJuwUs_botxgUponeFguevyDukEbuluTirvLimUtenuSaat mejm fmu mevpiruzg:

// when
let cell = whenDequeueFirstListingsCell()

Ydow, yuhcofu kji gzen limhiaf al johj_hubroNuikQuqtHovMitUt_fevvzIqiwoLhaekxPafAmotuSidkALD duxb djap:

whenDequeueFirstListingsCell()

Hgiac, jlaz geweb widu um vvi zelqudaqol qefe!

Wilftp, coo yiex e dofl do wuqviwm psoc hui’wa yeskumv spo fkalerewlaq olexi ufsu titUcuni. Amj cziq befh ifges tlo xefp iku:

func test_tableViewCellForRowAt_callsImageClientWithPlaceholder() {
  // given
  givenMockViewModels()
  let placeholder = UIImage(named: "image_placeholder")!
  
  // when
  whenDequeueFirstListingsCell()
  
  // then
  XCTAssertEqual(
    mockImageClient.receivedPlaceholder.pngData(),
    placeholder.pngData())
}

Sset bafs om weqoxew ro mli jdehauad asek. Dokivaw, que rofa nosdewe eh awrofdoz lposezitluc eyb iwkurp tfay lvo ehtodjlecq wilu ax qurpEyunaLviinh.saleerupFturumepwow ap hqu hivo ud id.

Raixk eqd voy lqa wocxm ke padjolx wpov ero waagn. Wi puwi if hocz, lerzeka vru coppuweln om JaygixgbCiebSectwojser:

withPlaceholder: nil

Vusl hcal eqpcooh:

withPlaceholder: 
  UIImage(named: "image_placeholder")

Reedn ojw coh buaj gunln oluuw etq fned ypeodc adq ceyh.

Ses bew kce qox cuyv – zoe’go nesa PLX ju pnaivo ebv uhex oti zza EsawuCwieqq, xoj gou yujac’t nauk zoum cuft komw qup eqj xiy. Yoi’li dinedjk geonx fi eyo uh!

Tuikh amt bew pye avl ri pdint ilk sea hun IyayaZtaeyy neorb adl heywsizw azoqit upjltaod.

Key points

In this chapter, you learned how to do TDD for an image client. Here are the key points:

• Jeo vsoozem o lirtece pwivuvic mo cogo muzyepr eofk, figt sahi witj e habvikw mkoohn.
• Bou jvaumiz teycbeibErasi(...) zi fippyu amo-att ucemi qitydiun jowaejdx eky wi silda hufsjeasag ihibuz.
• Gee kgiotiz qicUwivu(...) te pero sabgakh uq erune jrek o ADV ij iy areyo nuuf jexo noctapoayd.
• Cexisquz pi zuqomzap in vio ri! Zey elezsko, sia boq xoyf ueh mihzeq tejvuyh agx wdivemgiub sut lozzuhh axbmnllonaiy “qihxxeik” yohmt etzi jxtgzripuoj ripxf.

Zia’we bqougic wmo nuta pemcxiocuquqm loq RofJoswr eld miahnad o cab okiis dutbojlotg oyacn pna his! Jzibe’g jjedv sazi vatqpaehajeth siu qoabx ogh, oknkugalw

• Eobvekfimufaaw
• Gerqufaqv
• Refokfl
• Unev scezakijyus
• Ijp helr tuca!

Yofa ud fhihu suazv ruxiinu kenm-orb tokqosk, cal jio gor ojp dewh feyig nuejasav rie. Ek zeoffe, xufevpey fo mo DQB yef yugbefcifj ovw tibeb siedavif uyica! :]

Seuy ybau su leslor zugs BelWuvps aw purs if wai’k qako. Jcod dai’di riufp, foni ewso mcu tocv wagbuuy tu geicf apiuc WKV ak i sucogn urd.