Merge pull request #30 from WeTransfer/feature/url-matching-improvements

Improve the way we match registered Mocks

Author: AvdLee

.travis.yml

@@ -1,5 +1,5 @@
 language: objective-c
-osx_image: xcode10.2
+osx_image: xcode11.2
 gemfile: Gemfile
 bundler_args: "--without documentation --path bundle" # Don't download documentation for gems.
 cache:

Changelog.md

@@ -1,13 +1,16 @@
 ## Changelog
 
 ### Next
+
+### 2.0.0
 - A new completion callback can be set on `Mock` to use for expectation fulfilling once a `Mock` is completed.
 - A new onRequest callback can be set on `Mock` to use for expectation fulfilling once a `Mock` is requested.
 - Updated to Swift 5.0
 - Only dispatch to the background queue if needed
 - Correctly handle cancellation of delayed responses
 - Adding and reading mocks is now thread safe by using a Dispatch Semaphore
 - Add support for using Swift Package Manager
+- Improved checking for Mocks using `URLRequest`.
 
 ### 1.3.0
 - Updated to Swift 4.2

Mocker.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |spec|
   spec.name             = 'Mocker'
-  spec.version          = '1.3.0'
+  spec.version          = '2.0.0'
   spec.summary          = 'Mock data requests using a custom URLProtocol and run them offline.'
   spec.description      = 'Mocker is a library written in Swift which makes it possible to mock data requests using a custom URLProtocol and run them offline.'
 
@@ -13,7 +13,7 @@ Pod::Spec.new do |spec|
   spec.source           = { :git => 'https://github.com/WeTransfer/Mocker.git', :tag => spec.version.to_s }
   spec.social_media_url = 'https://twitter.com/WeTransfer'
 
-  spec.ios.deployment_target = '9.0'
+  spec.ios.deployment_target = '10.0'
   spec.source_files = 'Sources/**/*'
-  spec.swift_version = '4.2'
+  spec.swift_version = '5.1'
 end

Mocker.xcodeproj/project.pbxproj

@@ -30,6 +30,7 @@
 /* Begin PBXFileReference section */
 		501E26941F3DAE370048F39E /* Mocker.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Mocker.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 		501E269D1F3DAE370048F39E /* MockerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = MockerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
+		501F8B2D237594AC008EF77E /* Mocker.podspec */ = {isa = PBXFileReference; lastKnownFileType = text; path = Mocker.podspec; sourceTree = "<group>"; };
 		503446141F3DB4660039D5E4 /* Mock.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Mock.swift; sourceTree = "<group>"; };
 		503446151F3DB4660039D5E4 /* Mocker.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Mocker.swift; sourceTree = "<group>"; };
 		503446161F3DB4660039D5E4 /* MockingURLProtocol.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = MockingURLProtocol.swift; sourceTree = "<group>"; };
@@ -65,6 +66,7 @@
 			isa = PBXGroup;
 			children = (
 				506277CC235F2777000A4316 /* Changelog.md */,
+				501F8B2D237594AC008EF77E /* Mocker.podspec */,
 				501E26951F3DAE370048F39E /* Products */,
 				50D4606A20653F1F00A85D93 /* Mocker */,
 				50D4605A20653EAF00A85D93 /* MockerTests */,

MockerTests/MockerTests.swift

@@ -146,7 +146,7 @@ final class MockerTests: XCTestCase {
         let mock = Mock(dataType: .json, statusCode: 200, data: [.get: Data()], additionalHeaders: headers)
         mock.register()
 
-        URLSession.shared.dataTask(with: mock.url) { (_, response, error) in
+        URLSession.shared.dataTask(with: mock.request) { (_, response, error) in
             XCTAssert(error == nil)
             XCTAssert(((response as! HTTPURLResponse).allHeaderFields["testkey"] as! String) == "testvalue", "Additional headers should be added.")
             expectation.fulfill()
@@ -164,7 +164,7 @@ final class MockerTests: XCTestCase {
         let newMock = Mock(dataType: .json, statusCode: 200, data: [.get: Data()], additionalHeaders: ["newkey": "newvalue"])
         newMock.register()
 
-        URLSession.shared.dataTask(with: mock.url) { (_, response, error) in
+        URLSession.shared.dataTask(with: mock.request) { (_, response, error) in
             XCTAssert(error == nil)
             XCTAssert(((response as! HTTPURLResponse).allHeaderFields["newkey"] as! String) == "newvalue", "Additional headers should be added.")
             expectation.fulfill()
@@ -199,13 +199,13 @@ final class MockerTests: XCTestCase {
     }
 
     /// It should be possible to test cancellation of requests with a delayed mock.
-    func testDelayedMock() {
+    func testDelayedMockCancelation() {
         let expectation = self.expectation(description: "Data request should be cancelled")
         var mock = Mock(dataType: .json, statusCode: 200, data: [.get: Data()])
         mock.delay = DispatchTimeInterval.seconds(5)
         mock.register()
 
-        let task = URLSession.shared.dataTask(with: mock.url) { (_, _, error) in
+        let task = URLSession.shared.dataTask(with: mock.request) { (_, _, error) in
             XCTAssert(error?._code == NSURLErrorCancelled)
             expectation.fulfill()
         }
@@ -263,18 +263,46 @@ final class MockerTests: XCTestCase {
         XCTAssert(mock == urlRequest)
     }
 
-    /// It should call the completion callback when a `Mock` is used.
-    func testCompletionCallback() {
-        let expectation = self.expectation(description: "Data request should succeed")
+    /// It should call the onRequest and completion callbacks when a `Mock` is used and completed in the right order.
+    func testMockCallbacks() {
+        let onRequestExpectation = expectation(description: "Data request should start")
+        let completionExpectation = expectation(description: "Data request should succeed")
         var mock = Mock(dataType: .json, statusCode: 200, data: [.get: Data()])
+        mock.onRequest = {
+            onRequestExpectation.fulfill()
+        }
         mock.completion = {
-            expectation.fulfill()
+            completionExpectation.fulfill()
         }
         mock.register()
 
-        URLSession.shared.dataTask(with: mock.url).resume()
+        URLSession.shared.dataTask(with: mock.request).resume()
+
+        wait(for: [onRequestExpectation, completionExpectation], timeout: 2.0, enforceOrder: true)
+    }
+
+    /// It should call the mock after a delay.
+    func testDelayedMock() {
+        let nonDelayExpectation = expectation(description: "Data request should succeed")
+        let delayedExpectation = expectation(description: "Data request should succeed")
+        var delayedMock = Mock(dataType: .json, statusCode: 200, data: [.get: Data()])
+        delayedMock.delay = DispatchTimeInterval.seconds(1)
+        delayedMock.completion = {
+            delayedExpectation.fulfill()
+        }
+        delayedMock.register()
+        var nonDelayMock = Mock(dataType: .json, statusCode: 200, data: [.post: Data()])
+        nonDelayMock.completion = {
+            nonDelayExpectation.fulfill()
+        }
+        nonDelayMock.register()
+
+        XCTAssertNotEqual(delayedMock.request.url!, nonDelayMock.request.url!)
+
+        URLSession.shared.dataTask(with: delayedMock.request).resume()
+        URLSession.shared.dataTask(with: nonDelayMock.request).resume()
 
-        waitForExpectations(timeout: 2.0, handler: nil)
+        wait(for: [nonDelayExpectation, delayedExpectation], timeout: 2.0, enforceOrder: true)
     }
 
     /// It should remove all registered mocks correctly.

Sources/Mock.swift

@@ -64,8 +64,22 @@ public struct Mock: Equatable {
     /// The HTTP status code to return with the response.
     public let statusCode: Int
 
-    /// The URL value generated based on the Mock data.
-    public let url: URL
+    /// The URL value generated based on the Mock data. Force unwrapped on purpose. If you access this URL while it's not set, this is a programming error.
+    public var url: URL {
+        if urlToMock == nil && !data.keys.contains(.get) {
+            assertionFailure("For non GET mocks you should use the `request` property so the HTTP method is set.")
+        }
+        return urlToMock ?? generatedURL
+    }
+
+    /// The URL to mock as set implicitely from the init.
+    private let urlToMock: URL?
+
+    /// The URL generated from all the data set on this mock.
+    private let generatedURL: URL
+
+    /// The `URLRequest` to use if you did not set a specific URL.
+    public let request: URLRequest
 
     /// If `true`, checking the URL will ignore the query and match only for the scheme, host and path.
     public let ignoreQuery: Bool
@@ -86,7 +100,12 @@ public struct Mock: Equatable {
     public var onRequest: (() -> Void)?
 
     private init(url: URL? = nil, ignoreQuery: Bool = false, dataType: DataType, statusCode: Int, data: [HTTPMethod: Data], additionalHeaders: [String: String] = [:], fileExtensions: [String]? = nil) {
-        self.url = url ?? URL(string: "https://mocked.wetransfer.com/\(dataType.rawValue)/\(statusCode)/")!
+        self.urlToMock = url
+        let generatedURL = URL(string: "https://mocked.wetransfer.com/\(dataType.rawValue)/\(statusCode)/\(data.keys.first!.rawValue)")!
+        self.generatedURL = generatedURL
+        var request = URLRequest(url: url ?? generatedURL)
+        request.httpMethod = data.keys.first!.rawValue
+        self.request = request
         self.ignoreQuery = ignoreQuery
         self.dataType = dataType
         self.statusCode = statusCode
@@ -158,16 +177,16 @@ public struct Mock: Equatable {
             guard let pathExtension = request.url?.pathExtension else { return false }
             return fileExtensions.contains(pathExtension)
         } else if mock.ignoreQuery {
-            return mock.url.baseString == request.url?.baseString && mock.data.keys.contains(requestHTTPMethod)
+            return mock.request.url!.baseString == request.url?.baseString && mock.data.keys.contains(requestHTTPMethod)
         }
 
-        return mock.url.absoluteString == request.url?.absoluteString && mock.data.keys.contains(requestHTTPMethod)
+        return mock.request.url!.absoluteString == request.url?.absoluteString && mock.data.keys.contains(requestHTTPMethod)
     }
 
     public static func == (lhs: Mock, rhs: Mock) -> Bool {
         let lhsHTTPMethods: [String] = lhs.data.keys.compactMap { $0.rawValue }
         let rhsHTTPMethods: [String] = lhs.data.keys.compactMap { $0.rawValue }
-        return lhs.url.absoluteString == rhs.url.absoluteString && lhsHTTPMethods == rhsHTTPMethods
+        return lhs.request.url!.absoluteString == rhs.request.url!.absoluteString && lhsHTTPMethods == rhsHTTPMethods
     }
 }
 

Sources/Mocker.swift

@@ -29,7 +29,8 @@ public struct Mocker {
     /// URLs to ignore for mocking.
     private(set) var ignoredURLs: [URL] = []
 
-    private let mutex = DispatchSemaphore(value: 1)
+    /// For Thread Safety access.
+    private let queue = DispatchQueue(label: "mocker.mocks.access.queue", attributes: .concurrent)
 
     private init() {
         // Whenever someone is requesting the Mocker, we want the URL protocol to be activated.
@@ -40,7 +41,7 @@ public struct Mocker {
     ///
     /// - Parameter mock: The Mock to be registered for future requests.
     public static func register(_ mock: Mock) {
-        shared.mutex.lock {
+        shared.queue.async(flags: .barrier) {
             /// Delete the Mock if it was already registered.
             shared.mocks.removeAll(where: { $0 == mock })
             shared.mocks.append(mock)
@@ -51,7 +52,7 @@ public struct Mocker {
     ///
     /// - Parameter url: The URL to mock.
     public static func ignore(_ url: URL) {
-        return shared.mutex.lock {
+        shared.queue.async(flags: .barrier) {
             shared.ignoredURLs.append(url)
         }
     }
@@ -61,14 +62,14 @@ public struct Mocker {
     /// - Parameter url: The URL to check for.
     /// - Returns: `true` if it should be mocked, `false` if the URL is registered as ignored.
     public static func shouldHandle(_ url: URL) -> Bool {
-        return shared.mutex.lock {
+        shared.queue.sync {
             return !shared.ignoredURLs.contains(url)
         }
     }
 
     /// Removes all registered mocks. Use this method in your tearDown function to make sure a Mock is not used in any other test.
     public static func removeAll() {
-        shared.mutex.lock {
+        shared.queue.sync(flags: .barrier) {
             shared.mocks.removeAll()
         }
     }
@@ -78,7 +79,7 @@ public struct Mocker {
     /// - Parameter request: The request to search for a mock.
     /// - Returns: A mock if found, `nil` if there's no mocked data registered for the given request.
     static func mock(for request: URLRequest) -> Mock? {
-        return shared.mutex.lock {
+        shared.queue.sync {
             /// First check for specific URLs
             if let specificMock = shared.mocks.first(where: { $0 == request && $0.fileExtensions == nil }) {
                 return specificMock
@@ -88,11 +89,3 @@ public struct Mocker {
         }
     }
 }
-
-private extension DispatchSemaphore {
-    func lock<T>(execute task: () throws -> T) rethrows -> T {
-        wait()
-        defer { signal() }
-        return try task()
-    }
-}

Sources/MockingURLProtocol.swift

@@ -21,7 +21,7 @@ public final class MockingURLProtocol: URLProtocol {
     override public func startLoading() {
         guard
             let mock = Mocker.mock(for: request),
-            let response = HTTPURLResponse(url: mock.url, statusCode: mock.statusCode, httpVersion: Mocker.httpVersion.rawValue, headerFields: mock.headers),
+            let response = HTTPURLResponse(url: mock.request.url!, statusCode: mock.statusCode, httpVersion: Mocker.httpVersion.rawValue, headerFields: mock.headers),
             let data = mock.data(for: request)
         else {
             // swiftlint:disable nslog_prohibited

Submodules/WeTransfer-iOS-CI

@@ -19,13 +19,15 @@ lane :test do |options|
       clean: true,
       fail_build: false,
       code_coverage: true,
-      formatter: "xcpretty-json-formatter"
+      formatter: "xcpretty-json-formatter",
+      result_bundle: true,
+      output_directory: "build/reports/"
     )
   rescue => ex
     UI.error("Tests failed: #{ex}")
   end
 
-  trainer(output_directory: "build/reports/", fail_build: false)
+  trainer(path: "build/reports/", output_directory: "build/reports/", fail_build: false)
 
   validate_changes(project_name: options[:project_name])
 end