Merge pull request #6 from WeTransfer/feature/ignoreQueryMocking

Ignore query mocking

Author: AvdLee

Changelog.md

@@ -1,6 +1,14 @@
 ## Changelog
 
 ### Next
+- Ignoring query path for mocks
+- Missing mocks no longer break tests (removed fatalError)
+- Support for delayed responses
+- Support for redirect responses
+- Support for ignoring URLs for mocking
+- Support for ZIP content responses
+- Updated for Swift 4
+- Improved SwiftLint implementation
 
 ### 1.0 (2017-08-11)
 

Mocker/MockerTests/MockerTests.swift

@@ -62,6 +62,30 @@ final class MockerTests: XCTestCase {
 
         waitForExpectations(timeout: 10.0, handler: nil)
     }
+
+    /// It should correctly ignore queries if set.
+    func testIgnoreQueryMocking() {
+        let expectation = self.expectation(description: "Data request should succeed")
+        let originalURL = URL(string: "https://www.wetransfer.com/sample-image.png?width=200&height=200")!
+
+        Mock(url: originalURL, ignoreQuery: true, dataType: .imagePNG, statusCode: 200, data: [
+            .get: MockedData.botAvatarImageFileUrl.data
+        ]).register()
+
+        /// Make it different compared to the mocked URL.
+        let customURL = URL(string: originalURL.absoluteString + "&" + UUID().uuidString)!
+
+        URLSession.shared.dataTask(with: customURL) { (data, _, error) in
+            XCTAssert(error == nil)
+            let image: UIImage = UIImage(data: data!)!
+            let sampleImage: UIImage = UIImage(contentsOfFile: MockedData.botAvatarImageFileUrl.path)!
+
+            XCTAssert(image.size == sampleImage.size, "Image should be returned mocked")
+            expectation.fulfill()
+        }.resume()
+
+        waitForExpectations(timeout: 10.0, handler: nil)
+    }
 
     /// It should return the mocked JSON.
     func testJSONRequest() {

README.md

@@ -104,6 +104,29 @@ URLSession.shared.dataTask(with: originalURL) { (data, response, error) in
 }.resume()
 ```
 
+##### Ignoring the query
+Some URLs like authentication URLs contain timestamps or UUIDs in the query. To mock these you can ignore the Query for a certain URL:
+
+``` swift
+/// Would transform to "https://www.example.com/api/authentication?oauth_timestamp=151817037" for example.
+let originalURL = URL(string: "https://www.example.com/api/authentication")!
+    
+let mock = Mock(url: originalURL, ignoreQuery: true, contentType: .json, statusCode: 200, data: [
+    .get : MockedData.exampleJSON.data // Data containing the JSON response
+])
+mock.register()
+
+URLSession.shared.dataTask(with: originalURL) { (data, response, error) in
+    guard let data = data, let jsonDictionary = (try? JSONSerialization.jsonObject(with: data, options: [])) as? [String: Any] else {
+        return
+    }
+    
+    // jsonDictionary contains your JSON sample file data
+    // ..
+    
+}.resume()
+```
+
 ##### File extensions
 ```swift
 let imageURL = URL(string: "https://www.wetransfer.com/sample-image.png")!

Sources/Mock.swift

@@ -66,6 +66,9 @@ public struct Mock: Equatable {
 
     /// The URL value generated based on the Mock data.
     public let url: URL
+
+    /// If `true`, checking the URL will ignore the query and match only for the scheme, host and path.
+    public let ignoreQuery: Bool
 
     /// The file extensions to match for.
     public let fileExtensions: [String]?
@@ -76,16 +79,18 @@ public struct Mock: Equatable {
     /// Add a delay to a certain mock, which makes the response returned later.
     public var delay: DispatchTimeInterval?
 
-    private init(url: URL? = nil, dataType: DataType, statusCode: Int, data: [HTTPMethod: Data], additionalHeaders: [String: String] = [:], fileExtensions: [String]? = nil) {
+    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.ignoreQuery = ignoreQuery
         self.dataType = dataType
         self.statusCode = statusCode
         self.data = data
-        self.url = url ?? URL(string: "https://mocked.wetransfer.com/\(dataType.rawValue)/\(statusCode)/")!
-        self.fileExtensions = fileExtensions?.map({ $0.replacingOccurrences(of: ".", with: "") })
-        
+
         var headers = additionalHeaders
         headers["Content-Type"] = dataType.headerValue
         self.headers = headers
+
+        self.fileExtensions = fileExtensions?.map({ $0.replacingOccurrences(of: ".", with: "") })
     }
 
     /// Creates a `Mock` for the given data type. The mock will be automatically matched based on a URL created from the given parameters.
@@ -103,12 +108,13 @@ public struct Mock: Equatable {
     ///
     /// - Parameters:
     ///   - url: The URL to match for and to return the mocked data for.
+    ///   - ignoreQuery: If `true`, checking the URL will ignore the query and match only for the scheme, host and path. Defaults to `false`.
     ///   - dataType: The type of the data which is returned.
     ///   - statusCode: The HTTP status code to return with the response.
     ///   - data: The data which will be returned as the response based on the HTTP Method.
     ///   - additionalHeaders: Additional headers to be added to the response.
-    public init(url: URL, dataType: DataType, statusCode: Int, data: [HTTPMethod: Data], additionalHeaders: [String: String] = [:]) {
-        self.init(url: url, dataType: dataType, statusCode: statusCode, data: data, additionalHeaders: additionalHeaders, fileExtensions: nil)
+    public init(url: URL, ignoreQuery: Bool = false, dataType: DataType, statusCode: Int, data: [HTTPMethod: Data], additionalHeaders: [String: String] = [:]) {
+        self.init(url: url, ignoreQuery: ignoreQuery, dataType: dataType, statusCode: statusCode, data: data, additionalHeaders: additionalHeaders, fileExtensions: nil)
     }
 
     /// Creates a `Mock` for the given file extensions. The mock will only be used for urls matching the extension.
@@ -145,9 +151,11 @@ public struct Mock: Equatable {
             // If the mock contains a file extension, this should always be used to match for.
             guard let pathExtension = request.url?.pathExtension else { return false }
             return fileExtensions.contains(pathExtension)
-        } else {
-            return mock.url == request.url && mock.data.keys.contains(requestHTTPMethod)
+        } else if mock.ignoreQuery {
+            return mock.url.baseString == request.url?.baseString && mock.data.keys.contains(requestHTTPMethod)
         }
+
+        return mock.url == request.url && mock.data.keys.contains(requestHTTPMethod)
     }
 
     public static func == (lhs: Mock, rhs: Mock) -> Bool {
@@ -156,3 +164,11 @@ public struct Mock: Equatable {
         return lhs.url.absoluteString == rhs.url.absoluteString && lhsHTTPMethods == rhsHTTPMethods
     }
 }
+
+private extension URL {
+    /// Returns the base URL string build with the scheme, host and path. "https://www.wetransfer.com/v1/test?param=test" would be "https://www.wetransfer.com/v1/test".
+    var baseString: String? {
+        guard let scheme = scheme, let host = host else { return nil }
+        return scheme + "://" + host + path
+    }
+}