Renaming request -> URLRequest in tests

Tests/ParameterEncodingTests.swift

@@ -26,103 +26,103 @@ import XCTest
 
 class AlamofireURLParameterEncodingTestCase: XCTestCase {
     let encoding: ParameterEncoding = .URL
-    var request: NSURLRequest!
+    var URLRequest: NSURLRequest!
 
     override func setUp()  {
         super.setUp()
 
         let URL = NSURL(string: "http://example.com/")
-        self.request = NSURLRequest(URL: URL)
+        self.URLRequest = NSURLRequest(URL: URL)
     }
 
     // MARK: -
 
     func testURLParameterEncodeNilParameters() {
-        let (request, error) = self.encoding.encode(self.request, parameters: nil)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: nil)
 
-        XCTAssertNil(request.URL.query?, "query should be nil")
+        XCTAssertNil(URLRequest.URL.query?, "query should be nil")
     }
 
     func testURLParameterEncodeOneStringKeyStringValueParameter() {
         let parameters = ["foo": "bar"]
-        let (request, error) = self.encoding.encode(self.request, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: parameters)
 
-        XCTAssertEqual(request.URL.query!, "foo=bar", "query is incorrect")
+        XCTAssertEqual(URLRequest.URL.query!, "foo=bar", "query is incorrect")
     }
 
     func testURLParameterEncodeOneStringKeyStringValueParameterAppendedToQuery() {
-        var mutableURLRequest = self.request.mutableCopy() as NSMutableURLRequest
+        var mutableURLRequest = self.URLRequest.mutableCopy() as NSMutableURLRequest
         let URLComponents = NSURLComponents(URL: mutableURLRequest.URL!, resolvingAgainstBaseURL: false)
         URLComponents.query = "baz=qux"
         mutableURLRequest.URL = URLComponents.URL
 
         let parameters = ["foo": "bar"]
-        let (request, error) = self.encoding.encode(mutableURLRequest, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(mutableURLRequest, parameters: parameters)
 
-        XCTAssertEqual(request.URL.query!, "baz=qux&foo=bar", "query is incorrect")
+        XCTAssertEqual(URLRequest.URL.query!, "baz=qux&foo=bar", "query is incorrect")
     }
 
     func testURLParameterEncodeTwoStringKeyStringValueParameters() {
         let parameters = ["foo": "bar", "baz": "qux"]
-        let (request, error) = self.encoding.encode(self.request, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: parameters)
 
-        XCTAssertEqual(request.URL.query!, "baz=qux&foo=bar", "query is incorrect")
+        XCTAssertEqual(URLRequest.URL.query!, "baz=qux&foo=bar", "query is incorrect")
     }
 
     func testURLParameterEncodeStringKeyIntegerValueParameter() {
         let parameters = ["foo": 1]
-        let (request, error) = self.encoding.encode(self.request, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: parameters)
 
-        XCTAssertEqual(request.URL.query!, "foo=1", "query is incorrect")
+        XCTAssertEqual(URLRequest.URL.query!, "foo=1", "query is incorrect")
     }
 
     func testURLParameterEncodeStringKeyDoubleValueParameter() {
         let parameters = ["foo": 1.1]
-        let (request, error) = self.encoding.encode(self.request, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: parameters)
 
-        XCTAssertEqual(request.URL.query!, "foo=1.1", "query is incorrect")
+        XCTAssertEqual(URLRequest.URL.query!, "foo=1.1", "query is incorrect")
     }
 
     func testURLParameterEncodeStringKeyBoolValueParameter() {
         let parameters = ["foo": true]
-        let (request, error) = self.encoding.encode(self.request, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: parameters)
 
-        XCTAssertEqual(request.URL.query!, "foo=1", "query is incorrect")
+        XCTAssertEqual(URLRequest.URL.query!, "foo=1", "query is incorrect")
     }
 
     func testURLParameterEncodeStringKeyArrayValueParameter() {
         let parameters = ["foo": ["a", 1, true]]
-        let (request, error) = self.encoding.encode(self.request, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: parameters)
 
-        XCTAssertEqual(request.URL.query!, "foo%5B%5D=a&foo%5B%5D=1&foo%5B%5D=1", "query is incorrect")
+        XCTAssertEqual(URLRequest.URL.query!, "foo%5B%5D=a&foo%5B%5D=1&foo%5B%5D=1", "query is incorrect")
     }
 
     func testURLParameterEncodeStringKeyDictionaryValueParameter() {
         let parameters = ["foo": ["bar": 1]]
-        let (request, error) = self.encoding.encode(self.request, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: parameters)
 
-        XCTAssertEqual(request.URL.query!, "foo%5Bbar%5D=1", "query is incorrect")
+        XCTAssertEqual(URLRequest.URL.query!, "foo%5Bbar%5D=1", "query is incorrect")
     }
 
     func testURLParameterEncodeStringKeyNestedDictionaryValueParameter() {
         let parameters = ["foo": ["bar": ["baz": 1]]]
-        let (request, error) = self.encoding.encode(self.request, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: parameters)
 
-        XCTAssertEqual(request.URL.query!, "foo%5Bbar%5D%5Bbaz%5D=1", "query is incorrect")
+        XCTAssertEqual(URLRequest.URL.query!, "foo%5Bbar%5D%5Bbaz%5D=1", "query is incorrect")
     }
 
     func testURLParameterEncodeStringKeyNestedDictionaryArrayValueParameter() {
         let parameters = ["foo": ["bar": ["baz": ["a", 1, true]]]]
-        let (request, error) = self.encoding.encode(self.request, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: parameters)
 
-        XCTAssertEqual(request.URL.query!, "foo%5Bbar%5D%5Bbaz%5D%5B%5D=a&foo%5Bbar%5D%5Bbaz%5D%5B%5D=1&foo%5Bbar%5D%5Bbaz%5D%5B%5D=1", "query is incorrect")
+        XCTAssertEqual(URLRequest.URL.query!, "foo%5Bbar%5D%5Bbaz%5D%5B%5D=a&foo%5Bbar%5D%5Bbaz%5D%5B%5D=1&foo%5Bbar%5D%5Bbaz%5D%5B%5D=1", "query is incorrect")
     }
 
     func testURLParameterEncodeStringKeyPercentEncodedStringValueParameter() {
         let parameters = ["percent": "%25"]
-        let (request, error) = self.encoding.encode(self.request, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: parameters)
 
-        XCTAssertEqual(request.URL.query!, "percent=%2525", "query is incorrect")
+        XCTAssertEqual(URLRequest.URL.query!, "percent=%2525", "query is incorrect")
     }
 
     func testURLParameterEncodeStringKeyNonLatinStringValueParameter() {
@@ -132,56 +132,56 @@ class AlamofireURLParameterEncodingTestCase: XCTestCase {
             "arabic": "العربية",
             "emoji": "😃"
         ]
-        let (request, error) = self.encoding.encode(self.request, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: parameters)
 
-        XCTAssertEqual(request.URL.query!, "arabic=%D8%A7%D9%84%D8%B9%D8%B1%D8%A8%D9%8A%D8%A9&emoji=%F0%9F%98%83&french=fran%C3%A7ais&japanese=%E6%97%A5%E6%9C%AC%E8%AA%9E", "query is incorrect")
+        XCTAssertEqual(URLRequest.URL.query!, "arabic=%D8%A7%D9%84%D8%B9%D8%B1%D8%A8%D9%8A%D8%A9&emoji=%F0%9F%98%83&french=fran%C3%A7ais&japanese=%E6%97%A5%E6%9C%AC%E8%AA%9E", "query is incorrect")
     }
 
     func testURLParameterEncodeGETParametersInURL() {
-        var mutableURLRequest = self.request.mutableCopy() as NSMutableURLRequest
+        var mutableURLRequest = self.URLRequest.mutableCopy() as NSMutableURLRequest
         mutableURLRequest.HTTPMethod = Method.GET.toRaw()
 
         let parameters = ["foo": 1, "bar": 2]
-        let (request, error) = self.encoding.encode(mutableURLRequest, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(mutableURLRequest, parameters: parameters)
 
-        XCTAssertEqual(request.URL.query!, "bar=2&foo=1", "query is incorrect")
-        XCTAssertNil(request.valueForHTTPHeaderField("Content-Type"), "Content-Type should be nil")
-        XCTAssertNil(request.HTTPBody, "HTTPBody should be nil")
+        XCTAssertEqual(URLRequest.URL.query!, "bar=2&foo=1", "query is incorrect")
+        XCTAssertNil(URLRequest.valueForHTTPHeaderField("Content-Type"), "Content-Type should be nil")
+        XCTAssertNil(URLRequest.HTTPBody, "HTTPBody should be nil")
     }
 
     func testURLParameterEncodePOSTParametersInHTTPBody() {
-        var mutableURLRequest = self.request.mutableCopy() as NSMutableURLRequest
+        var mutableURLRequest = self.URLRequest.mutableCopy() as NSMutableURLRequest
         mutableURLRequest.HTTPMethod = Method.POST.toRaw()
 
         let parameters = ["foo": 1, "bar": 2]
-        let (request, error) = self.encoding.encode(mutableURLRequest, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(mutableURLRequest, parameters: parameters)
 
-        XCTAssertEqual(NSString(data: request.HTTPBody!, encoding: NSUTF8StringEncoding), "bar=2&foo=1", "HTTPBody is incorrect")
-        XCTAssertEqual(request.valueForHTTPHeaderField("Content-Type")!, "application/x-www-form-urlencoded", "Content-Type should be application/x-www-form-urlencoded")
-        XCTAssertNotNil(request.HTTPBody, "HTTPBody should not be nil")
+        XCTAssertEqual(NSString(data: URLRequest.HTTPBody!, encoding: NSUTF8StringEncoding), "bar=2&foo=1", "HTTPBody is incorrect")
+        XCTAssertEqual(URLRequest.valueForHTTPHeaderField("Content-Type")!, "application/x-www-form-urlencoded", "Content-Type should be application/x-www-form-urlencoded")
+        XCTAssertNotNil(URLRequest.HTTPBody, "HTTPBody should not be nil")
     }
 }
 
 class AlamofireJSONParameterEncodingTestCase: XCTestCase {
     let encoding: ParameterEncoding = .JSON
-    var request: NSURLRequest!
+    var URLRequest: NSURLRequest!
 
     override func setUp()  {
         super.setUp()
 
         let URL = NSURL(string: "http://example.com/")
-        self.request = NSURLRequest(URL: URL)
+        self.URLRequest = NSURLRequest(URL: URL)
     }
 
     // MARK: -
 
     func testJSONParameterEncodeNilParameters() {
-        let (request, error) = self.encoding.encode(self.request, parameters: nil)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: nil)
 
         XCTAssertNil(error, "error should be nil")
-        XCTAssertNil(request.URL.query?, "query should be nil")
-        XCTAssertNil(request.valueForHTTPHeaderField("Content-Type"), "Content-Type should be nil")
-        XCTAssertNil(request.HTTPBody, "HTTPBody should be nil")
+        XCTAssertNil(URLRequest.URL.query?, "query should be nil")
+        XCTAssertNil(URLRequest.valueForHTTPHeaderField("Content-Type"), "Content-Type should be nil")
+        XCTAssertNil(URLRequest.HTTPBody, "HTTPBody should be nil")
     }
 
     func testJSONParameterEncodeComplexParameters() {
@@ -194,15 +194,15 @@ class AlamofireJSONParameterEncodingTestCase: XCTestCase {
                    ]
         ]
 
-        let (request, error) = self.encoding.encode(self.request, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: parameters)
 
         XCTAssertNil(error, "error should be nil")
-        XCTAssertNil(request.URL.query?, "query should be nil")
-        XCTAssertNotNil(request.valueForHTTPHeaderField("Content-Type"), "Content-Type should not be nil")
-        XCTAssert(request.valueForHTTPHeaderField("Content-Type")!.hasPrefix("application/json"), "Content-Type should be application/json")
-        XCTAssertNotNil(request.HTTPBody, "HTTPBody should not be nil")
+        XCTAssertNil(URLRequest.URL.query?, "query should be nil")
+        XCTAssertNotNil(URLRequest.valueForHTTPHeaderField("Content-Type"), "Content-Type should not be nil")
+        XCTAssert(URLRequest.valueForHTTPHeaderField("Content-Type")!.hasPrefix("application/json"), "Content-Type should be application/json")
+        XCTAssertNotNil(URLRequest.HTTPBody, "HTTPBody should not be nil")
 
-        let JSON = NSJSONSerialization.JSONObjectWithData(request.HTTPBody!, options: .AllowFragments, error: nil) as NSObject!
+        let JSON = NSJSONSerialization.JSONObjectWithData(URLRequest.HTTPBody!, options: .AllowFragments, error: nil) as NSObject!
         XCTAssertNotNil(JSON, "HTTPBody JSON is invalid")
         XCTAssertEqual(JSON as NSObject, parameters as NSObject, "HTTPBody JSON does not equal parameters")
     }
@@ -210,24 +210,24 @@ class AlamofireJSONParameterEncodingTestCase: XCTestCase {
 
 class AlamofirePropertyListParameterEncodingTestCase: XCTestCase {
     let encoding: ParameterEncoding = .PropertyList(.XMLFormat_v1_0, 0)
-    var request: NSURLRequest!
+    var URLRequest: NSURLRequest!
 
     override func setUp()  {
         super.setUp()
 
         let URL = NSURL(string: "http://example.com/")
-        self.request = NSURLRequest(URL: URL)
+        self.URLRequest = NSURLRequest(URL: URL)
     }
 
     // MARK: -
 
     func testPropertyListParameterEncodeNilParameters() {
-        let (request, error) = self.encoding.encode(self.request, parameters: nil)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: nil)
 
         XCTAssertNil(error, "error should be nil")
-        XCTAssertNil(request.URL.query?, "query should be nil")
-        XCTAssertNil(request.valueForHTTPHeaderField("Content-Type"), "Content-Type should be nil")
-        XCTAssertNil(request.HTTPBody, "HTTPBody should be nil")
+        XCTAssertNil(URLRequest.URL.query?, "query should be nil")
+        XCTAssertNil(URLRequest.valueForHTTPHeaderField("Content-Type"), "Content-Type should be nil")
+        XCTAssertNil(URLRequest.HTTPBody, "HTTPBody should be nil")
     }
 
     func testPropertyListParameterEncodeComplexParameters() {
@@ -240,15 +240,15 @@ class AlamofirePropertyListParameterEncodingTestCase: XCTestCase {
             ]
         ]
 
-        let (request, error) = self.encoding.encode(self.request, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: parameters)
 
         XCTAssertNil(error, "error should be nil")
-        XCTAssertNil(request.URL.query?, "query should be nil")
-        XCTAssertNotNil(request.valueForHTTPHeaderField("Content-Type"), "Content-Type should not be nil")
-        XCTAssert(request.valueForHTTPHeaderField("Content-Type")!.hasPrefix("application/x-plist"), "Content-Type should be application/x-plist")
-        XCTAssertNotNil(request.HTTPBody, "HTTPBody should not be nil")
+        XCTAssertNil(URLRequest.URL.query?, "query should be nil")
+        XCTAssertNotNil(URLRequest.valueForHTTPHeaderField("Content-Type"), "Content-Type should not be nil")
+        XCTAssert(URLRequest.valueForHTTPHeaderField("Content-Type")!.hasPrefix("application/x-plist"), "Content-Type should be application/x-plist")
+        XCTAssertNotNil(URLRequest.HTTPBody, "HTTPBody should not be nil")
 
-        let plist = NSPropertyListSerialization.propertyListWithData(request.HTTPBody!, options: 0, format: nil, error: nil) as NSObject
+        let plist = NSPropertyListSerialization.propertyListWithData(URLRequest.HTTPBody!, options: 0, format: nil, error: nil) as NSObject
         XCTAssertNotNil(plist, "HTTPBody JSON is invalid")
         XCTAssertEqual(plist as NSObject, parameters as NSObject, "HTTPBody plist does not equal parameters")
     }
@@ -262,15 +262,15 @@ class AlamofirePropertyListParameterEncodingTestCase: XCTestCase {
             "data": data
         ]
 
-        let (request, error) = self.encoding.encode(self.request, parameters: parameters)
+        let (URLRequest, error) = self.encoding.encode(self.URLRequest, parameters: parameters)
 
         XCTAssertNil(error, "error should be nil")
-        XCTAssertNil(request.URL.query?, "query should be nil")
-        XCTAssertNotNil(request.valueForHTTPHeaderField("Content-Type"), "Content-Type should not be nil")
-        XCTAssert(request.valueForHTTPHeaderField("Content-Type")!.hasPrefix("application/x-plist"), "Content-Type should be application/x-plist")
-        XCTAssertNotNil(request.HTTPBody, "HTTPBody should not be nil")
+        XCTAssertNil(URLRequest.URL.query?, "query should be nil")
+        XCTAssertNotNil(URLRequest.valueForHTTPHeaderField("Content-Type"), "Content-Type should not be nil")
+        XCTAssert(URLRequest.valueForHTTPHeaderField("Content-Type")!.hasPrefix("application/x-plist"), "Content-Type should be application/x-plist")
+        XCTAssertNotNil(URLRequest.HTTPBody, "HTTPBody should not be nil")
 
-        let plist = NSPropertyListSerialization.propertyListWithData(request.HTTPBody!, options: 0, format: nil, error: nil) as NSObject!
+        let plist = NSPropertyListSerialization.propertyListWithData(URLRequest.HTTPBody!, options: 0, format: nil, error: nil) as NSObject!
         XCTAssertNotNil(plist, "HTTPBody JSON is invalid")
         XCTAssert(plist.valueForKey("date") is NSDate, "date is not NSDate")
         XCTAssert(plist.valueForKey("data") is NSData, "data is not NSData")
@@ -290,6 +290,6 @@ class AlamofireCustomParameterEncodingTestCase: XCTestCase {
         let URLRequest = NSURLRequest(URL: NSURL(string: "http://example.com"))
         let parameters: [String: AnyObject] = [:]
 
-        XCTAssertEqual(encoding.encode(URLRequest, parameters: parameters).0, encodingClosure(URLRequest, parameters).0, "request should be equal")
+        XCTAssertEqual(encoding.encode(URLRequest, parameters: parameters).0, encodingClosure(URLRequest, parameters).0, "URLRequest should be equal")
     }
 }