Added 204 support to response serializers and removed data length checks.

Source/ResponseSerialization.swift

@@ -145,11 +145,13 @@ extension Request {
         - returns: A data response serializer.
     */
     public static func dataResponseSerializer() -> ResponseSerializer<NSData, NSError> {
-        return ResponseSerializer { _, _, data, error in
+        return ResponseSerializer { _, response, data, error in
             guard error == nil else { return .Failure(error!) }
 
-            guard let validData = data where validData.length > 0 else {
-                let failureReason = "Data could not be serialized. Input data was nil or zero length."
+            guard response?.statusCode ?? -1 != 204 else { return .Success(NSData()) }
+
+            guard let validData = data else {
+                let failureReason = "Data could not be serialized. Input data was nil."
                 let error = Error.errorWithCode(.DataSerializationFailed, failureReason: failureReason)
                 return .Failure(error)
             }
@@ -190,8 +192,10 @@ extension Request {
         return ResponseSerializer { _, response, data, error in
             guard error == nil else { return .Failure(error!) }
 
-            guard let validData = data where validData.length > 0 else {
-                let failureReason = "String could not be serialized. Input data was nil or zero length."
+            guard response?.statusCode ?? -1 != 204 else { return .Success("") }
+
+            guard let validData = data else {
+                let failureReason = "String could not be serialized. Input data was nil."
                 let error = Error.errorWithCode(.StringSerializationFailed, failureReason: failureReason)
                 return .Failure(error)
             }
@@ -252,11 +256,13 @@ extension Request {
         options options: NSJSONReadingOptions = .AllowFragments)
         -> ResponseSerializer<AnyObject, NSError>
     {
-        return ResponseSerializer { _, _, data, error in
+        return ResponseSerializer { _, response, data, error in
             guard error == nil else { return .Failure(error!) }
 
-            guard let validData = data where validData.length > 0 else {
-                let failureReason = "JSON could not be serialized. Input data was nil or zero length."
+            guard response?.statusCode ?? -1 != 204 else { return .Success(NSNull()) }
+
+            guard let validData = data else {
+                let failureReason = "JSON could not be serialized. Input data was nil."
                 let error = Error.errorWithCode(.JSONSerializationFailed, failureReason: failureReason)
                 return .Failure(error)
             }
@@ -306,11 +312,13 @@ extension Request {
         options options: NSPropertyListReadOptions = NSPropertyListReadOptions())
         -> ResponseSerializer<AnyObject, NSError>
     {
-        return ResponseSerializer { _, _, data, error in
+        return ResponseSerializer { _, response, data, error in
             guard error == nil else { return .Failure(error!) }
 
-            guard let validData = data where validData.length > 0 else {
-                let failureReason = "Property list could not be serialized. Input data was nil or zero length."
+            guard response?.statusCode ?? -1 != 204 else { return .Success(NSNull()) }
+
+            guard let validData = data else {
+                let failureReason = "Property list could not be serialized. Input data was nil."
                 let error = Error.errorWithCode(.PropertyListSerializationFailed, failureReason: failureReason)
                 return .Failure(error)
             }

Tests/ResponseSerializationTests.swift

@@ -83,6 +83,47 @@ class ResponseSerializationTestCase: BaseTestCase {
         }
     }
 
+    func testThatDataResponseSerializerFailsWhenDataIsNilWithNon204ResponseStatusCode() {
+        // Given
+        let serializer = Request.dataResponseSerializer()
+        let URL = NSURL(string: "https://httpbin.org/get")!
+        let response = NSHTTPURLResponse(URL: URL, statusCode: 200, HTTPVersion: "HTTP/1.1", headerFields: nil)
+
+        // When
+        let result = serializer.serializeResponse(nil, response, nil, nil)
+
+        // Then
+        XCTAssertTrue(result.isFailure, "result is failure should be true")
+        XCTAssertNil(result.value, "result value should be nil")
+        XCTAssertNotNil(result.error, "result error should not be nil")
+
+        if let error = result.error {
+            XCTAssertEqual(error.domain, Error.Domain, "error domain should match expected value")
+            XCTAssertEqual(error.code, Error.Code.DataSerializationFailed.rawValue, "error code should match expected value")
+        } else {
+            XCTFail("error should not be nil")
+        }
+    }
+
+    func testThatDataResponseSerializerSucceedsWhenDataIsNilWith204ResponseStatusCode() {
+        // Given
+        let serializer = Request.dataResponseSerializer()
+        let URL = NSURL(string: "https://httpbin.org/get")!
+        let response = NSHTTPURLResponse(URL: URL, statusCode: 204, HTTPVersion: "HTTP/1.1", headerFields: nil)
+
+        // When
+        let result = serializer.serializeResponse(nil, response, nil, nil)
+
+        // Then
+        XCTAssertTrue(result.isSuccess, "result is success should be true")
+        XCTAssertNotNil(result.value, "result value should not be nil")
+        XCTAssertNil(result.error, "result error should be nil")
+
+        if let data = result.value {
+            XCTAssertEqual(data.length, 0, "data length should be zero")
+        }
+    }
+
     // MARK: - String Response Serializer Tests
 
     func testThatStringResponseSerializerFailsWhenDataIsNil() {
@@ -105,7 +146,7 @@ class ResponseSerializationTestCase: BaseTestCase {
         }
     }
 
-    func testThatStringResponseSerializerFailsWhenDataIsEmpty() {
+    func testThatStringResponseSerializerSucceedsWhenDataIsEmpty() {
         // Given
         let serializer = Request.stringResponseSerializer()
 
@@ -113,9 +154,9 @@ class ResponseSerializationTestCase: BaseTestCase {
         let result = serializer.serializeResponse(nil, nil, NSData(), nil)
 
         // Then
-        XCTAssertTrue(result.isFailure, "result is failure should be true")
-        XCTAssertNil(result.value, "result value should be nil")
-        XCTAssertNotNil(result.error, "result error should not be nil")
+        XCTAssertTrue(result.isSuccess, "result is success should be true")
+        XCTAssertNotNil(result.value, "result value should not be nil")
+        XCTAssertNil(result.error, "result error should be nil")
     }
 
     func testThatStringResponseSerializerSucceedsWithUTF8DataAndNoProvidedEncoding() {
@@ -231,6 +272,47 @@ class ResponseSerializationTestCase: BaseTestCase {
         }
     }
 
+    func testThatStringResponseSerializerFailsWhenDataIsNilWithNon204ResponseStatusCode() {
+        // Given
+        let serializer = Request.stringResponseSerializer()
+        let URL = NSURL(string: "https://httpbin.org/get")!
+        let response = NSHTTPURLResponse(URL: URL, statusCode: 200, HTTPVersion: "HTTP/1.1", headerFields: nil)
+
+        // When
+        let result = serializer.serializeResponse(nil, response, nil, nil)
+
+        // Then
+        XCTAssertTrue(result.isFailure, "result is failure should be true")
+        XCTAssertNil(result.value, "result value should be nil")
+        XCTAssertNotNil(result.error, "result error should not be nil")
+
+        if let error = result.error {
+            XCTAssertEqual(error.domain, Error.Domain, "error domain should match expected value")
+            XCTAssertEqual(error.code, Error.Code.StringSerializationFailed.rawValue, "error code should match expected value")
+        } else {
+            XCTFail("error should not be nil")
+        }
+    }
+
+    func testThatStringResponseSerializerSucceedsWhenDataIsNilWith204ResponseStatusCode() {
+        // Given
+        let serializer = Request.stringResponseSerializer()
+        let URL = NSURL(string: "https://httpbin.org/get")!
+        let response = NSHTTPURLResponse(URL: URL, statusCode: 204, HTTPVersion: "HTTP/1.1", headerFields: nil)
+
+        // When
+        let result = serializer.serializeResponse(nil, response, nil, nil)
+
+        // Then
+        XCTAssertTrue(result.isSuccess, "result is success should be true")
+        XCTAssertNotNil(result.value, "result value should not be nil")
+        XCTAssertNil(result.error, "result error should be nil")
+
+        if let string = result.value {
+            XCTAssertEqual(string, "", "string should be equal to empty string")
+        }
+    }
+
     // MARK: - JSON Response Serializer Tests
 
     func testThatJSONResponseSerializerFailsWhenDataIsNil() {
@@ -266,8 +348,8 @@ class ResponseSerializationTestCase: BaseTestCase {
         XCTAssertNotNil(result.error, "result error should not be nil")
 
         if let error = result.error {
-            XCTAssertEqual(error.domain, Error.Domain, "error domain should match expected value")
-            XCTAssertEqual(error.code, Error.Code.JSONSerializationFailed.rawValue, "error code should match expected value")
+            XCTAssertEqual(error.domain, "NSCocoaErrorDomain", "error domain should match expected value")
+            XCTAssertEqual(error.code, 3840, "error code should match expected value")
         } else {
             XCTFail("error should not be nil")
         }
@@ -328,6 +410,47 @@ class ResponseSerializationTestCase: BaseTestCase {
         }
     }
 
+    func testThatJSONResponseSerializerFailsWhenDataIsNilWithNon204ResponseStatusCode() {
+        // Given
+        let serializer = Request.JSONResponseSerializer()
+        let URL = NSURL(string: "https://httpbin.org/get")!
+        let response = NSHTTPURLResponse(URL: URL, statusCode: 200, HTTPVersion: "HTTP/1.1", headerFields: nil)
+
+        // When
+        let result = serializer.serializeResponse(nil, response, nil, nil)
+
+        // Then
+        XCTAssertTrue(result.isFailure, "result is failure should be true")
+        XCTAssertNil(result.value, "result value should be nil")
+        XCTAssertNotNil(result.error, "result error should not be nil")
+
+        if let error = result.error {
+            XCTAssertEqual(error.domain, Error.Domain, "error domain should match expected value")
+            XCTAssertEqual(error.code, Error.Code.JSONSerializationFailed.rawValue, "error code should match expected value")
+        } else {
+            XCTFail("error should not be nil")
+        }
+    }
+
+    func testThatJSONResponseSerializerSucceedsWhenDataIsNilWith204ResponseStatusCode() {
+        // Given
+        let serializer = Request.JSONResponseSerializer()
+        let URL = NSURL(string: "https://httpbin.org/get")!
+        let response = NSHTTPURLResponse(URL: URL, statusCode: 204, HTTPVersion: "HTTP/1.1", headerFields: nil)
+
+        // When
+        let result = serializer.serializeResponse(nil, response, nil, nil)
+
+        // Then
+        XCTAssertTrue(result.isSuccess, "result is success should be true")
+        XCTAssertNotNil(result.value, "result value should not be nil")
+        XCTAssertNil(result.error, "result error should be nil")
+
+        if let json = result.value as? NSNull {
+            XCTAssertEqual(json, NSNull(), "json should be equal to NSNull")
+        }
+    }
+
     // MARK: - Property List Response Serializer Tests
 
     func testThatPropertyListResponseSerializerFailsWhenDataIsNil() {
@@ -363,8 +486,8 @@ class ResponseSerializationTestCase: BaseTestCase {
         XCTAssertNotNil(result.error, "result error should not be nil")
 
         if let error = result.error {
-            XCTAssertEqual(error.domain, Error.Domain, "error domain should match expected value")
-            XCTAssertEqual(error.code, Error.Code.PropertyListSerializationFailed.rawValue, "error code should match expected value")
+            XCTAssertEqual(error.domain, "NSCocoaErrorDomain", "error domain should match expected value")
+            XCTAssertEqual(error.code, 3840, "error code should match expected value")
         } else {
             XCTFail("error should not be nil")
         }
@@ -424,4 +547,45 @@ class ResponseSerializationTestCase: BaseTestCase {
             XCTFail("error should not be nil")
         }
     }
+
+    func testThatPropertyListResponseSerializerFailsWhenDataIsNilWithNon204ResponseStatusCode() {
+        // Given
+        let serializer = Request.propertyListResponseSerializer()
+        let URL = NSURL(string: "https://httpbin.org/get")!
+        let response = NSHTTPURLResponse(URL: URL, statusCode: 200, HTTPVersion: "HTTP/1.1", headerFields: nil)
+
+        // When
+        let result = serializer.serializeResponse(nil, response, nil, nil)
+
+        // Then
+        XCTAssertTrue(result.isFailure, "result is failure should be true")
+        XCTAssertNil(result.value, "result value should be nil")
+        XCTAssertNotNil(result.error, "result error should not be nil")
+
+        if let error = result.error {
+            XCTAssertEqual(error.domain, Error.Domain, "error domain should match expected value")
+            XCTAssertEqual(error.code, Error.Code.PropertyListSerializationFailed.rawValue, "error code should match expected value")
+        } else {
+            XCTFail("error should not be nil")
+        }
+    }
+
+    func testThatPropertyListResponseSerializerSucceedsWhenDataIsNilWith204ResponseStatusCode() {
+        // Given
+        let serializer = Request.propertyListResponseSerializer()
+        let URL = NSURL(string: "https://httpbin.org/get")!
+        let response = NSHTTPURLResponse(URL: URL, statusCode: 204, HTTPVersion: "HTTP/1.1", headerFields: nil)
+
+        // When
+        let result = serializer.serializeResponse(nil, response, nil, nil)
+
+        // Then
+        XCTAssertTrue(result.isSuccess, "result is success should be true")
+        XCTAssertNotNil(result.value, "result value should not be nil")
+        XCTAssertNil(result.error, "result error should be nil")
+
+        if let plist = result.value as? NSNull {
+            XCTAssertEqual(plist, NSNull(), "plist should be equal to NSNull")
+        }
+    }
 }