Add test for header fields being sent to the server.

Author: danieleggert

Foundation/NSURLSession/Configuration.swift

@@ -104,8 +104,6 @@ internal extension NSURLSession.Configuration {
         HTTPAdditionalHeaders?.forEach {
             request.setValue($0.1, forHTTPHeaderField: $0.0)
         }
-        //TODO:
-        // request.allowsCellularAccess = allowsCellularAccess
     }
     func setCookies(request request: NSMutableURLRequest) {
         if HTTPShouldSetCookies {

TestFoundation/HTTPServer.swift

@@ -312,6 +312,14 @@ struct HTTPRequest {
   }
 }
 
+extension HTTPRequest {
+    func forEachHeaderField(@noescape handler: (name: String, value: String) -> ()) {
+        message.headers.forEach {
+            handler(name: $0.name, value: $0.value)
+        }
+    }
+}
+
 /// A HTTP response
 ///
 /// - SeeAlso: RFC 2616 Section 6

TestFoundation/TestNSURLSession.swift

@@ -115,7 +115,74 @@ extension TaskDelegate: NSURLSessionDataDelegate {
     }
 }
 
+//MARK: - Header Field Helpers
 
+private struct HeaderFields {
+    let fields: [(name: String, value: String)]
+}
+extension HeaderFields {
+    func value(forField name: String) -> String? {
+        let lowercasedName = name.lowercased()
+        return fields.index(where: { lowercasedName == $0.name.lowercased() }).map { fields[$0].value }
+    }
+    var count: Int { return fields.count }
+}
+extension HeaderFields {
+    func hasValue(forField name: String) -> Bool {
+        return value(forField: name) != nil
+    }
+}
+
+
+/// Tests that the header fields with the given names exist.
+private func AssertHeaderFieldsExist(@autoclosure expression1: () throws -> HeaderFields, @autoclosure _ expression2: () throws -> [String], @autoclosure _ message: () -> String = "", file: StaticString = #file, line: UInt = #line) {
+    let m = message()
+    do {
+        let f = try expression1()
+        try expression2().forEach {
+            if !f.hasValue(forField: $0) {
+                XCTFail(file: file, line: line, "Field '\($0)' is missing. " + m)
+            }
+        }
+    } catch let e { XCTFail(file: file, line: line, "\(m) -- \(e)") }
+}
+/// Tests that header fields only exist for the given names and nothing else.
+private func AssertHeaderFieldNamesEqual(@autoclosure expression1: () throws -> HeaderFields, @autoclosure _ expression2: () throws -> [String], @autoclosure _ message: () -> String = "", file: StaticString = #file, line: UInt = #line) {
+    let m = message()
+    do {
+        let fields = try expression1()
+        var extraNames = fields.fields.map { $0.name }
+        try expression2().forEach { field in
+            if let idx = extraNames.index(where: { field.lowercased() == $0.lowercased() }) {
+                extraNames.remove(at: idx)
+            } else {
+                XCTFail(file: file, line: line, "Header field '\(field)' is missing. " + m)
+            }
+        }
+        extraNames.forEach {
+            let value = fields.value(forField: $0) ?? ""
+            XCTFail(file: file, line: line, "Extranous header field '\($0): \(value)'. " + m)
+        }
+        
+    } catch let e { XCTFail(file: file, line: line, "\(m) -- \(e)") }
+}
+/// Tests the the header fields match those in the dictionary, *and* that all
+/// fields in the dictionary exist. But the headers might have more values.
+private func AssertHeaderFieldsEqual(@autoclosure expression1: () throws -> HeaderFields, @autoclosure _ expression2: () throws -> [String:String], @autoclosure _ message: () -> String = "", file: StaticString = #file, line: UInt = #line) {
+    let m = message()
+    do {
+        let f = try expression1()
+        try expression2().forEach { field in
+            if let v = f.value(forField: field.0) {
+                XCTAssertEqual(v, field.1, file: file, line: line, "Header field '\(field.0)'. \(m)")
+            } else {
+                XCTFail(file: file, line: line, "Header field '\(field.0)' is missing. \(m)")
+            }
+        }
+    } catch let e { XCTFail(file: file, line: line, "\(m) -- \(e)") }
+}
+
+//MARK: - Tests
 
 class TestNSURLSession : XCTestCase {
     static var allTests: [(String, TestNSURLSession -> () throws -> Void)] {
@@ -130,6 +197,8 @@ class TestNSURLSession : XCTestCase {
             ("test_functional_POST_fromData", test_functional_POST_fromData),
             ("test_functional_POST_fromFile", test_functional_POST_fromFile),
             ("test_functional_POST_fromFileThatDoesNotExist", test_functional_POST_fromFileThatDoesNotExist),
+        
+            ("test_functional_defaultHeaders", test_functional_defaultHeaders),
         ]
     }
 
@@ -146,8 +215,8 @@ class TestNSURLSession : XCTestCase {
         let task = sut.dataTaskWithURL(NSURL(string: "http://swift.org/")!)
         XCTAssertEqual(task.state, NSURLSessionTaskState.Suspended)
     }
-    
-    func createServer(file: StaticString = #file, line: UInt = #line, handler: (HTTPRequest) -> (HTTPResponse)) -> (SocketServer, NSURL)? {
+    /// Create an HTTP server and return the server and its base URL.
+    private func createServer(file file: StaticString = #file, line: UInt = #line, handler: (HTTPRequest) -> HTTPResponse) -> (SocketServer, NSURL)? {
         let q = dispatch_queue_create("test_2", DISPATCH_QUEUE_SERIAL)
         let server: SocketServer
         do {
@@ -167,6 +236,30 @@ class TestNSURLSession : XCTestCase {
         c.path = "/"
         return (server, c.URL!)
     }
+    /// Creates an HTTP server with a block that gets all headers.
+    private func createExtractHeaderServer(file file: StaticString = #file, line: UInt = #line, headerHandler: (HeaderFields) -> ()) -> (SocketServer, NSURL)? {
+        return createServer(file: file, line: line) { request in
+            var headerFields: [(name: String, value: String)] = []
+            request.forEachHeaderField {
+                headerFields.append((name: $0, value: $1))
+            }
+            headerHandler(HeaderFields(fields: headerFields))
+            return HTTPResponse(statusCode: 200, additionalHeaderFields: [], body: "")
+        }
+    }
+    /// Helper function that creates a session with a delegate and calls the
+    /// given closure with all three wrapped in a `withExtendedLifetime()` call.
+    private func with(server server: SocketServer, @noescape testClosure: (NSURLSession, TaskDelegate) -> ()) {
+        withExtendedLifetime(server) {
+            let delegate = TaskDelegate()
+            let session = NSURLSession(configuration: NSURLSessionConfiguration.defaultSessionConfiguration(), delegate: delegate, delegateQueue: queue)
+            withExtendedLifetime(delegate) {
+                withExtendedLifetime(session) {
+                    testClosure(session, delegate)
+                }
+            }
+        }
+    }
 }
 
 /// Create test data with a well-defined pattern.
@@ -545,9 +638,37 @@ extension TestNSURLSession {
         }
     }
 
+    
     //TODO: Uploading data with completion handler
     // public func uploadTaskWithRequest(request: NSURLRequest, fromFile fileURL: NSURL, completionHandler: (NSData?, NSURLResponse?, NSError?) -> Void) -> NSURLSessionUploadTask
     // public func uploadTaskWithRequest(request: NSURLRequest, fromData bodyData: NSData?, completionHandler: (NSData?, NSURLResponse?, NSError?) -> Void) -> NSURLSessionUploadTask
+
+    func test_functional_defaultHeaders() {
+        var baseURL: NSURL?
+        guard let (server, _baseURL) = createExtractHeaderServer(headerHandler: { headers in
+            let port = Int(baseURL?.port ?? 0)
+            let expected = ["Host": "\(baseURL?.host ?? ""):\(String(port))",
+                            "Accept": "*/*",
+                            "Accept-Language": "en-us",
+                            "Accept-Encoding": "gzip, deflate",
+                            ]
+            AssertHeaderFieldsEqual(headers, expected)
+            AssertHeaderFieldNamesEqual(headers, ["Host", "Accept", "Accept-Language", "Accept-Encoding", "Connection", "User-Agent"])
+        }) else { XCTFail(); return }
+        baseURL = _baseURL
+        with(server: server) { (session, delegate) in
+            let URL = NSURL(string: "/bar", relativeToURL: baseURL)!
+            
+            let completionExpectation = expectationWithDescription("Task did complete")
+            let task = session.dataTaskWithURL(URL, completionHandler: { (_, _, _) in
+                completionExpectation.fulfill()
+            })
+            
+            task.resume()
+            waitForExpectationsWithTimeout(1, handler: nil)
+            XCTAssertEqual(task.state, NSURLSessionTaskState.Completed)
+        }
+    }
 }
 
 private extension HTTPResponse {