Add HTTPBody and HTTPBodyStream, remove allowsCellularAccess

Author: danieleggert

Foundation/NSURLRequest.swift

@@ -179,9 +179,10 @@ public class NSURLRequest : NSObject, NSSecureCoding, NSCopying, NSMutableCopyin
         cachePolicy = other.cachePolicy
         timeoutInterval = other.timeoutInterval
         networkServiceType = other.networkServiceType
-        allowsCellularAccess = other.allowsCellularAccess
         HTTPMethod = other.HTTPMethod
         allHTTPHeaderFields = other.allHTTPHeaderFields
+        HTTPBody = other.HTTPBody
+        HTTPBodyStream = other.HTTPBodyStream
     }
 
     public override func mutableCopy() -> AnyObject {
@@ -255,11 +256,29 @@ public class NSURLRequest : NSObject, NSSecureCoding, NSCopying, NSMutableCopyin
     */
     /*@NSCopying */public private(set) var URL: NSURL?
 
+    /// The cache policy of the receiver.
     public private(set) var cachePolicy: NSURLRequestCachePolicy = .UseProtocolCachePolicy
+    
+    /// The timeout interval.
+    ///
+    /// The timeout interval specifies the limit on the idle
+    /// interval allotted to a request in the process of loading. The *idle
+    /// interval* is defined as the period of time that has passed since the
+    /// last instance of load activity occurred for a request that is in the
+    /// process of loading. Hence, when an instance of load activity occurs
+    /// (e.g. bytes are received from the network for a request), the idle
+    /// interval for a request is reset to 0. If the idle interval ever
+    /// becomes greater than or equal to the timeout interval, the request
+    /// is considered to have timed out. This timeout interval is measured
+    /// in seconds.
     public private(set) var timeoutInterval: NSTimeInterval = 60
+    
+    /// The `NSURLRequestNetworkServiceType` associated with this request.
+    ///
+    /// This method is used to provide the network layers with a hint as to the
+    /// purpose of the request.  Most clients should not need to use this method.
     public private(set) var networkServiceType: NSURLRequestNetworkServiceType = .NetworkServiceTypeDefault
-    public private(set) var allowsCellularAccess: Bool = true
-
+    
     /*!
         @method mainDocumentURL
         @abstract The main document URL associated with this load.
@@ -286,6 +305,23 @@ public class NSURLRequest : NSObject, NSSecureCoding, NSCopying, NSMutableCopyin
     */
     public private(set) var allHTTPHeaderFields: [String: String]?
 
+    /// HTTP body data.
+    ///
+    /// This is sent as the message body, as in an HTTP POST request.
+    public private(set) var HTTPBody: NSData? {
+        didSet { precondition(HTTPBody == nil || HTTPBodyStream == nil, "Must not set both HTTPBody and HTTPBodyStream.") }
+    }
+    
+    /// HTTP body stream.
+    ///
+    /// - Returns: `nil` if the body stream has not been set. The returned stream is for examination only -- it is not safe to manipulate the stream in any way.
+    ///
+    /// - Note: A request can have an HTTP body or an HTTP body stream, only one may be set for a request.
+    /// - Note: A HTTP body stream is preserved when copying an NSURLRequest object, but is lost when a request is archived using the NSCoding protocol.
+    public private(set) var HTTPBodyStream: NSInputStream? {
+        didSet { precondition(HTTPBody == nil || HTTPBodyStream == nil, "Must not set both HTTPBody and HTTPBodyStream.") }
+    }
+    
     /*!
     @method valueForHTTPHeaderField:
     @abstract Returns the value which corresponds to the given header
@@ -332,9 +368,6 @@ public class NSURLRequest : NSObject, NSSecureCoding, NSCopying, NSMutableCopyin
     </ul>
 */
 public class NSMutableURLRequest : NSURLRequest {
-    
-    private var _HTTPMethod: String? = "GET"
-    
     public required init?(coder aDecoder: NSCoder) {
         super.init()
     }
@@ -378,21 +411,55 @@ public class NSMutableURLRequest : NSURLRequest {
         set { super.HTTPMethod = newValue }
     }
 
+    /// The cache policy of the receiver.
     public override var cachePolicy: NSURLRequestCachePolicy {
         get { return super.cachePolicy }
         set { super.cachePolicy = newValue }
     }
+    
+    /// The timeout interval.
+    ///
+    /// The timeout interval specifies the limit on the idle
+    /// interval allotted to a request in the process of loading. The *idle
+    /// interval* is defined as the period of time that has passed since the
+    /// last instance of load activity occurred for a request that is in the
+    /// process of loading. Hence, when an instance of load activity occurs
+    /// (e.g. bytes are received from the network for a request), the idle
+    /// interval for a request is reset to 0. If the idle interval ever
+    /// becomes greater than or equal to the timeout interval, the request
+    /// is considered to have timed out. This timeout interval is measured
+    /// in seconds.
     public override var timeoutInterval: NSTimeInterval {
         get { return super.timeoutInterval }
         set { super.timeoutInterval = newValue }
     }
+    
+    /// The `NSURLRequestNetworkServiceType` associated with this request.
+    ///
+    /// This method is used to provide the network layers with a hint as to the
+    /// purpose of the request.  Most clients should not need to use this method.
     public override var networkServiceType: NSURLRequestNetworkServiceType {
         get { return super.networkServiceType }
         set { super.networkServiceType = newValue }
     }
-    public override var allowsCellularAccess: Bool {
-        get { return super.allowsCellularAccess }
-        set { super.allowsCellularAccess = newValue }
+    
+    /// HTTP body data.
+    ///
+    /// This is sent as the message body, as in an HTTP POST request.
+    public override var HTTPBody: NSData? {
+        get { return super.HTTPBody }
+        set { super.HTTPBody = newValue.map({ $0.copy() as! NSData }) }
+    }
+    
+    /// HTTP body stream.
+    ///
+    /// - Returns: `nil` if the body stream has not been set. The returned stream is for examination only -- it is not safe to manipulate the stream in any way.
+    ///
+    /// - Note: A request can have an HTTP body or an HTTP body stream, only one may be set for a request.
+    /// - Note: A HTTP body stream is preserved when copying an NSURLRequest object, but is lost when a request is archived using the NSCoding protocol.
+    public override var HTTPBodyStream: NSInputStream? {
+        get { return super.HTTPBodyStream }
+        set { super.HTTPBodyStream = newValue }
     }
 
     /*!

TestFoundation/TestNSURLRequest.swift

@@ -37,9 +37,10 @@ class TestNSURLRequest : XCTestCase {
         XCTAssertEqual(request.cachePolicy, NSURLRequestCachePolicy.UseProtocolCachePolicy)
         XCTAssertEqual(request.timeoutInterval, 60)
         XCTAssertEqual(request.networkServiceType, NSURLRequestNetworkServiceType.NetworkServiceTypeDefault)
-        XCTAssertEqual(request.allowsCellularAccess, true)
         XCTAssertNil(request.allHTTPHeaderFields)
         XCTAssertNil(request.mainDocumentURL)
+        XCTAssertNil(request.HTTPBody)
+        XCTAssertNil(request.HTTPBodyStream)
     }
 
     func test_mutableConstruction() {
@@ -53,9 +54,10 @@ class TestNSURLRequest : XCTestCase {
         XCTAssertEqual(request.cachePolicy, NSURLRequestCachePolicy.UseProtocolCachePolicy)
         XCTAssertEqual(request.timeoutInterval, 60)
         XCTAssertEqual(request.networkServiceType, NSURLRequestNetworkServiceType.NetworkServiceTypeDefault)
-        XCTAssertEqual(request.allowsCellularAccess, true)
         XCTAssertNil(request.allHTTPHeaderFields)
         XCTAssertNil(request.mainDocumentURL)
+        XCTAssertNil(request.HTTPBody)
+        XCTAssertNil(request.HTTPBodyStream)
 
         request.mainDocumentURL = URL
         XCTAssertEqual(request.mainDocumentURL, URL)
@@ -75,14 +77,23 @@ class TestNSURLRequest : XCTestCase {
         request.networkServiceType = newServiceType
         XCTAssertEqual(request.networkServiceType, newServiceType)
 
-        request.allowsCellularAccess = false
-        XCTAssertEqual(request.allowsCellularAccess, false)
+        let newData = NSMutableData()
+        newData.appendData("A".dataUsingEncoding(NSUTF8StringEncoding)!)
+        request.HTTPBody = newData
+        newData.appendData("B".dataUsingEncoding(NSUTF8StringEncoding)!)
+        if let d = request.HTTPBody {
+            XCTAssertEqual(String(data: d, encoding: NSUTF8StringEncoding), "A")
+        } else {
+            XCTFail()
+        }
 
         let newURL = NSURL(string: "http://github.com")!
         request.URL = newURL
         XCTAssertEqual(request.URL, newURL)
     }
 
+    //TODO: Test HTTPBodyStream when NSInputStream is implemented.
+    
     func test_headerFields() {
         let request = NSMutableURLRequest(URL: URL)