Merge pull request #3 from modestman/feature/pattern-matching

Pattern matching

Author: Alexander-Ignition

README.md

@@ -143,6 +143,41 @@ final class LoginUITests: XCTestCase {
 }
 ```
 
+### Request patterns
+
+You can specify a pattern for catch http requests and make a response with mock data. Pattern matching applied for URL and http headers in the request. See `RequestPattern` struct.
+
+Three types of patterns can be used:
+
+- `equal` - the request value must be exactly the same as the pattern value,
+- `wildcard` - the request value match with the wildcard pattern (see below),
+- `regexp` - the request value match with the regular expression pattern.
+
+##### Note: 
+If you want to apply a wildcard pattern for the url query parameters, don't forget escape `?` symbol after domain or path.
+
+```swift
+Pattern.wildcard("http://example.com\?query=*")
+```
+
+### Wildcard pattern
+
+"Wildcards" are the patterns you type when you do stuff like `ls *.js` on the command line, or put `build/*` in a `.gitignore` file.
+
+In our implementation any wildcard pattern translates to regular expression and applies matching with URL or header string.
+
+The following characters have special magic meaning when used in a pattern:
+
+- `*` matches 0 or more characters in a single path portion
+- `?` matches 1 character
+- `[a-z]` matches a range of characters, similar to a RegExp range. 
+- `{bar,baz}` matches one of the substitution listed in braces. For example pattern  `foo{bar,baz}` matches strings `foobar` or `foobaz`
+
+You can escape special characters with backslash `\`.
+
+Negation in groups is not supported.
+
+
 ## Example project
 
 ```bash

Sources/CatbirdAPI/Pattern.swift

@@ -0,0 +1,64 @@
+import Foundation
+
+/// The kind of pattern for matching request fields such as url and headers
+public struct Pattern: Codable, Hashable {
+    
+    // MARK: - Public types
+    
+    /// - equal: The request value must be equal to the pattern value
+    /// - wildcard: The request value match with the wildcard pattern
+    /// - regexp: The request value match with the regular expression pattern
+    public enum Kind: String, Codable {
+        case equal, wildcard, regexp
+    }
+    
+    
+    // MARK: - Public properties
+    
+    public let kind: Kind
+    public let value: String
+    
+    
+    // MARK: - Init
+    
+    public init(kind: Kind, value: String) {
+        self.kind = kind
+        self.value = value
+    }
+    
+    public static func equal(_ value: String) -> Pattern {
+        return Pattern(kind: .equal, value: value)
+    }
+    
+    public static func wildcard(_ value: String) -> Pattern {
+        return Pattern(kind: .wildcard, value: value)
+    }
+    
+    public static func regexp(_ value: String) -> Pattern {
+        return Pattern(kind: .regexp, value: value)
+    }
+}
+
+
+/// Protocol for converting common types to Pattern
+public protocol PatternRepresentable {
+    var pattern: Pattern { get }
+}
+
+extension Pattern: PatternRepresentable {
+    public var pattern: Pattern {
+        return self
+    }
+}
+
+extension String: PatternRepresentable {
+    public var pattern: Pattern {
+        return .equal(self)
+    }
+}
+
+extension URL: PatternRepresentable {
+    public var pattern: Pattern {
+        return .equal(self.absoluteString)
+    }
+}

Sources/CatbirdAPI/RequestPattern.swift

@@ -6,53 +6,54 @@ import Foundation
 public struct RequestPattern: Codable, Hashable {
 
     public func hash(into hasher: inout Hasher) {
-        hasher.combine(url.absoluteString)
+        hasher.combine(url.value)
         hasher.combine(method)
+        hasher.combine(headerFields)
     }
 
     /// HTTP method.
     public let method: String
 
     /// Request URL.
-    public let url: URL
+    public let url: Pattern
 
     /// Request required headers. Default empty.
-    public let headerFields: [String: String]
+    public let headerFields: [String: Pattern]
 
     /// A new request pattern.
     ///
     /// - Parameters:
     ///   - method: HTTP method.
-    ///   - url: Request URL.
+    ///   - url: Request URL or pattern.
     ///   - headerFields: Request required headers. Default empty.
-    public init(method: String, url: URL, headerFields: [String: String] = [:]) {
+    public init(method: String, url: PatternRepresentable, headerFields: [String: PatternRepresentable] = [:]) {
         self.method = method
-        self.url = url
-        self.headerFields = headerFields
+        self.url = url.pattern
+        self.headerFields = headerFields.mapValues { $0.pattern }
     }
 
     /// A new pattern for `GET` request.
-    public static func get(_ url: URL, headerFields: [String: String] = [:]) -> RequestPattern {
+    public static func get(_ url: PatternRepresentable, headerFields: [String: PatternRepresentable] = [:]) -> RequestPattern {
         return RequestPattern(method: "GET", url: url, headerFields: headerFields)
     }
 
     /// A new pattern for `POST` request.
-    public static func post(_ url: URL, headerFields: [String: String] = [:]) -> RequestPattern {
+    public static func post(_ url: PatternRepresentable, headerFields: [String: PatternRepresentable] = [:]) -> RequestPattern {
         return RequestPattern(method: "POST", url: url, headerFields: headerFields)
     }
 
     /// A new pattern for `PUT` request.
-    public static func put(_ url: URL, headerFields: [String: String] = [:]) -> RequestPattern {
+    public static func put(_ url: PatternRepresentable, headerFields: [String: PatternRepresentable] = [:]) -> RequestPattern {
         return RequestPattern(method: "PUT", url: url, headerFields: headerFields)
     }
 
     /// A new pattern for `PATCH` request.
-    public static func patch(_ url: URL, headerFields: [String: String] = [:]) -> RequestPattern {
+    public static func patch(_ url: PatternRepresentable, headerFields: [String: PatternRepresentable] = [:]) -> RequestPattern {
         return RequestPattern(method: "PATCH", url: url, headerFields: headerFields)
     }
 
     /// A new pattern for `DELETE` request.
-    public static func delete(_ url: URL, headerFields: [String: String] = [:]) -> RequestPattern {
+    public static func delete(_ url: PatternRepresentable, headerFields: [String: PatternRepresentable] = [:]) -> RequestPattern {
         return RequestPattern(method: "DELETE", url: url, headerFields: headerFields)
     }
 

Sources/CatbirdApp/Model/Pattern+Match.swift

@@ -0,0 +1,17 @@
+import CatbirdAPI
+
+extension Pattern {
+    
+    func match(_ someValue: String) -> Bool {
+        let pattern = value
+        switch kind {
+        case .equal:
+            return pattern == someValue
+        case .wildcard:
+            return Wildcard(pattern: pattern).check(someValue)
+        case .regexp:
+            return someValue.range(of: pattern , options: [.regularExpression, .caseInsensitive]) != nil
+        }
+    }
+    
+}

Sources/CatbirdApp/Model/RequestPattern+HTTP.swift

@@ -6,17 +6,24 @@ extension RequestPattern {
     init(httpRequest: HTTPRequest) {
         var headers: [String: String] = [:]
         httpRequest.headers.forEach { headers[$0.name] = $0.value }
-
+        
         self.init(
             method: httpRequest.method.string,
             url: httpRequest.url,
             headerFields: headers)
     }
 
     func match(_ httpRequest: HTTPRequest) -> Bool {
-        // TODO: check headers
-
-        return httpRequest.method.string == method
-            && httpRequest.url == url
+        var result = httpRequest.method.string == method
+        result = result && url.match(httpRequest.url.absoluteString)
+        for patternHeader in headerFields {
+            // We not support multiple headers with the same key
+            if let value = httpRequest.headers[patternHeader.key].first {
+                result = result && patternHeader.value.match(value)
+            } else {
+                return false
+            }
+        }
+        return result
     }
 }

Sources/CatbirdApp/Model/Wildcard.swift

@@ -0,0 +1,87 @@
+import Foundation
+
+/// Convert wildcard pattern to regular expression and check string match.
+public struct Wildcard {
+    
+    let pattern: String
+
+    public init(pattern: String) {
+        self.pattern = pattern
+    }
+    
+    /// Translate wildcard pattern to regular expression pattern
+    ///
+    /// - Returns: Regular expression pattern string
+    public func regexPattern() -> String {
+        let patternChars = [Character](pattern)
+        var result = ""
+        var index = 0
+        var inGroup = false
+        
+        while index < patternChars.count {
+            let char = patternChars[index]
+            
+            switch char {
+            case "/", "$", "^", "+", ".", "(", ")", "=", "!", "|":
+                result.append("\\\(char)")
+            case "\\":
+                // Escaping next character
+                if index + 1 < patternChars.count {
+                    result.append("\\")
+                    result.append(patternChars[index + 1])
+                    index += 1
+                } else {
+                    result.append("\\\\")
+                }
+            case "?":
+                result.append(".")
+            case "[", "]":
+                result.append(char)
+            case "{":
+                inGroup = true
+                result.append("(")
+            case "}":
+                inGroup = false
+                result.append(")")
+            case ",":
+                if inGroup {
+                    result.append("|")
+                } else {
+                    result.append("\\\(char)")
+                }
+            case "*":
+                // Move over all consecutive "*"'s.
+                while(index + 1 < patternChars.count && patternChars[index + 1] == "*") {
+                    index += 1
+                }
+                // Treat any number of "*" as one
+                result.append(".*")
+            default:
+                result.append(char)
+            }
+            index += 1
+        }
+        
+        return "^\(result)$"
+    }
+    
+    /// Make regular expression object from wildcard pattern
+    ///
+    /// - Returns: An instance of NSRegularExpression
+    public func toRegex(caseInsensitive: Bool = true) throws -> NSRegularExpression {
+        var options: NSRegularExpression.Options = [.anchorsMatchLines]
+        if caseInsensitive {
+            options = options.union([.caseInsensitive])
+        }
+        return try NSRegularExpression(pattern: regexPattern(), options: options)
+    }
+    
+    /// Checks that given string match to wildcard pattern
+    public func check(_ testingString: String, caseInsensitive: Bool = true) -> Bool {
+        var options: String.CompareOptions = [.regularExpression]
+        if caseInsensitive {
+            options = options.union([.caseInsensitive])
+        }
+        return testingString.range(of: regexPattern() , options: options) != nil
+    }
+}

Sources/CatbirdApp/Store/BagsResponseStore.swift

@@ -2,5 +2,5 @@ import CatbirdAPI
 
 protocol BagsResponseStore {
 
-    var bags: [RequestPattern : ResponseData] { get }
+    var bags: [RequestBag] { get }
 }

Sources/CatbirdApp/Store/DataResponseStore.swift

@@ -3,20 +3,28 @@ import Vapor
 
 final class DataResponseStore: ResponseStore, BagsResponseStore {
 
-    private(set) var bags: [RequestPattern : ResponseData] = [:]
+    private(set) var bags: [RequestBag] = []
 
     // MARK: - ResponseStore
 
     func response(for request: Request) throws -> Response {
-        let pattern = RequestPattern(method: request.http.method.string,
-                                     url: request.http.url,
-                                     headerFields: [:])
-        guard let response = bags[pattern] else { throw Abort(.notFound) }
-        return request.response(http: response.httpResponse)
+        for bag in bags where bag.pattern.match(request.http) {
+            return request.response(http: bag.data.httpResponse)
+        }
+        throw Abort(.notFound)
     }
 
     func setResponse(data: ResponseData?, for pattern: RequestPattern) throws {
-        bags[pattern] = data
+        guard let data = data else { 
+            bags.removeAll { $0.pattern == pattern }
+            return
+        }
+        let bag = RequestBag(pattern: pattern, data: data)
+        if let index = bags.firstIndex(where: { $0.pattern == pattern }) {
+            bags[index] = bag
+        } else {
+            bags.append(bag)
+        }
     }
 
     func removeAllResponses() throws {

Sources/CatbirdApp/Store/FileResponseStore.swift

@@ -23,9 +23,15 @@ final class FileResponseStore: ResponseStore {
 
     func setResponse(data: ResponseData?, for pattern: RequestPattern) throws {
         guard let body = data?.body else { return }
-
-        let url = URL(fileURLWithPath: path + pattern.url.path, isDirectory: false)
-        try createDirectories(for: pattern.url)
+        
+        let patternPath: String
+        if case .equal = pattern.url.kind, let url = URL(string: pattern.url.value) {
+            patternPath = url.path
+        } else {
+            patternPath = pattern.url.value.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? ""
+        }
+        let url = URL(fileURLWithPath: path + patternPath, isDirectory: false)
+        try createDirectories(for: url)
         try body.write(to: url)
     }
 
@@ -34,16 +40,8 @@ final class FileResponseStore: ResponseStore {
     // MARK: - Private
 
     private func createDirectories(for url: URL) throws {
-        // Remove first component "/" and last with file name
-        let pathComponents = url.pathComponents.dropFirst().dropLast()
-        guard !pathComponents.isEmpty else { return }
-
-        try pathComponents
-            .indices
-            .map { pathComponents[...$0].joined(separator: "/") }
-            .map { "\(path)/\($0)" }
-            .filter { !fileManager.fileExists(atPath: $0, isDirectory: nil) }
-            .map { URL(fileURLWithPath: $0, isDirectory: true) }
-            .forEach { try fileManager.createDirectory(at: $0, withIntermediateDirectories: true) }
+        // Remove file name
+        let dirUrl = url.deletingLastPathComponent()
+        try fileManager.createDirectory(at: dirUrl, withIntermediateDirectories: true)
     }
 }