Allow simulation of slow image loading by "pausing" the URL protocol

This ensures we are synchronously simulating the callbacks queueing up,
but without relying on coincidental async timing - one less flaky test.
Failure localization of runUntil() is also improved.

Author: Andrew Kitchen

MapboxNavigationTests/ImageDownloaderTests.swift

@@ -61,7 +61,7 @@ class ImageDownloaderTests: XCTestCase {
         XCTAssertNil(errorReturned)
     }
 
-    func testDownloadingSameImageWhileInProgressAddsCallbacksWithoutAddingAnotherRequest() {
+    func testDownloadingImageWhileAlreadyInProgressAddsCallbacksWithoutAddingAnotherRequest() {
         guard let downloader = downloader else {
             XCTFail()
             return
@@ -70,6 +70,9 @@ class ImageDownloaderTests: XCTestCase {
         var secondCallbackCalled = false
         var operation: ImageDownload
 
+        // URL loading is delayed in order to simulate conditions under which multiple requests for the same asset would be made
+        ImageLoadingURLProtocolSpy.delayImageLoading()
+
         downloader.downloadImage(with: imageURL) { (image, data, error) in
             firstCallbackCalled = true
         }
@@ -79,14 +82,17 @@ class ImageDownloaderTests: XCTestCase {
             secondCallbackCalled = true
         }
 
+        ImageLoadingURLProtocolSpy.resumeImageLoading()
+
         XCTAssertTrue(operation === downloader.activeOperation(with: imageURL)!,
                       "Expected \(String(describing: operation)) to be identical to \(String(describing: downloader.activeOperation(with: imageURL)))")
 
         var spinCount = 0
-        runUntil(condition: {
+
+        runUntil({
             spinCount += 1
             return operation.isFinished
-        }, pollingInterval: 0.1, until: XCTestCase.NavigationTests.timeout)
+        })
 
         print("Succeeded after evaluating condition \(spinCount) times.")
 
@@ -107,10 +113,10 @@ class ImageDownloaderTests: XCTestCase {
         }
         var operation = downloader.activeOperation(with: imageURL)!
 
-        runUntil(condition: {
+        runUntil({
             spinCount += 1
             return operation.isFinished
-        }, pollingInterval: 0.1, until: XCTestCase.NavigationTests.timeout)
+        })
 
         print("Succeeded after evaluating first condition \(spinCount) times.")
         XCTAssertTrue(callbackCalled)
@@ -123,24 +129,28 @@ class ImageDownloaderTests: XCTestCase {
         }
         operation = downloader.activeOperation(with: imageURL)!
 
-        runUntil(condition: {
+        runUntil({
             spinCount += 1
             return operation.isFinished
-        }, pollingInterval: 0.1, until: XCTestCase.NavigationTests.timeout)
+        })
 
         print("Succeeded after evaluating second condition \(spinCount) times.")
         XCTAssertTrue(callbackCalled)
     }
 
-    private func runUntil(condition: () -> Bool, pollingInterval: TimeInterval, until timeout: DispatchTime) {
+    private func runUntil(_ condition: () -> Bool, testCase: String = #function) {
+        runUntil(condition: condition, testCase: testCase, pollingInterval: NavigationTests.pollingInterval, until: NavigationTests.timeout)
+    }
+
+    private func runUntil(condition: () -> Bool, testCase: String, pollingInterval: TimeInterval, until timeout: DispatchTime) {
         guard (timeout >= DispatchTime.now()) else {
-            XCTFail("Timeout occurred on \(#function)")
+            XCTFail("Timeout occurred in \(testCase)")
             return
         }
 
         if condition() == false {
             RunLoop.current.run(until: Date(timeIntervalSinceNow: pollingInterval))
-            runUntil(condition: condition, pollingInterval: pollingInterval, until: timeout)
+            runUntil(condition: condition, testCase: testCase, pollingInterval: pollingInterval, until: timeout)
         }
     }
 }

MapboxNavigationTests/Support/ImageLoadingURLProtocolSpy.swift

@@ -9,8 +9,9 @@ class ImageLoadingURLProtocolSpy: URLProtocol {
     private static var responseData: [URL: Data] = [:]
     private static var activeRequests: [URL: URLRequest] = [:]
     private static var pastRequests: [URL: URLRequest] = [:]
+    private static let imageLoadingSemaphore = DispatchSemaphore(value: 1)
 
-    private var stopped: Bool = false
+    private var loadingStopped: Bool = false
 
     override class func canInit(with request: URLRequest) -> Bool {
         return responseData.keys.contains(request.url!)
@@ -37,7 +38,6 @@ class ImageLoadingURLProtocolSpy: URLProtocol {
             return
         }
 
-        // retrieve fake response (image) for request; ensure it is an image
         guard let data = ImageLoadingURLProtocolSpy.responseData[url], let image: UIImage = UIImage(data: data), let client = client else {
             XCTFail("No valid image data found for url: \(url)")
             return
@@ -49,25 +49,30 @@ class ImageLoadingURLProtocolSpy: URLProtocol {
                 ImageLoadingURLProtocolSpy.activeRequests[url] = nil
             }
 
-            XCTAssertFalse(self.stopped, "URL Loading was previously stopped")
-            
+            XCTAssertFalse(self.loadingStopped, "URL Loading was previously stopped")
+
             // We only want there to be one active request per resource at any given time (with callbacks appended if requested multiple times)
             XCTAssertFalse(ImageLoadingURLProtocolSpy.hasActiveRequestForURL(url), "There should only be one request in flight at a time per resource")
             ImageLoadingURLProtocolSpy.activeRequests[url] = request
 
             // send an NSHTTPURLResponse to the client
             let response = HTTPURLResponse.init(url: url, statusCode: 200, httpVersion: "1.1", headerFields: nil)
             client.urlProtocol(self, didReceive: response!, cacheStoragePolicy: .notAllowed)
+
+            ImageLoadingURLProtocolSpy.imageLoadingSemaphore.wait()
+
             client.urlProtocol(self, didLoad: UIImagePNGRepresentation(image)!)
             client.urlProtocolDidFinishLoading(self)
+
+            ImageLoadingURLProtocolSpy.imageLoadingSemaphore.signal()
         }
 
         let defaultQueue = DispatchQueue.global(qos: .default)
         defaultQueue.async(execute: urlLoadingBlock)
     }
 
     override func stopLoading() {
-        stopped = true
+        loadingStopped = true
     }
 
     /**
@@ -99,4 +104,19 @@ class ImageLoadingURLProtocolSpy: URLProtocol {
     class func pastRequestForURL(_ url: URL) -> URLRequest? {
         return pastRequests[url]
     }
+
+    /**
+     * Pauses image loading once a request receives a response. Useful for testing re-entrant resource requests.
+     */
+    class func delayImageLoading() {
+        ImageLoadingURLProtocolSpy.imageLoadingSemaphore.wait()
+    }
+
+    /**
+     * Resumes image loading which was previously delayed due to `delayImageLoading()` having been called.
+     */
+    class func resumeImageLoading() {
+        ImageLoadingURLProtocolSpy.imageLoadingSemaphore.signal()
+    }
+
 }

MapboxNavigationTests/XCTestCase.swift

@@ -6,5 +6,7 @@ extension XCTestCase {
         static var timeout: DispatchTime {
             return DispatchTime.now() + DispatchTimeInterval.seconds(10)
         }
+
+        static let pollingInterval: TimeInterval = 0.05
     }
 }