Merge pull request #284 from zapcannon87/developer

fix(storage): batch save can do with empty requests

Author: zapcannon87

LeanCloudTests/LCObjectTestCase.swift

@@ -21,11 +21,13 @@ class LCObjectTestCase: BaseTestCase {
         XCTAssertNil(wObject)
     }
 
-    func testSaveObject() {
+    func testSave() {
         let object = TestObject()
 
         XCTAssertTrue(object.save().isSuccess)
         XCTAssertNotNil(object.objectId)
+        
+        XCTAssertTrue(object.save().isSuccess)
     }
 
     func testSaveObjectWithOption() {
@@ -90,7 +92,7 @@ class LCObjectTestCase: BaseTestCase {
         XCTAssertNotNil(newbornOrphan5.objectId)
     }
 
-    func testBatchSave() {
+    func testSaveObjects() {
         let object1 = TestObject()
         let object2 = TestObject()
 
@@ -115,6 +117,8 @@ class LCObjectTestCase: BaseTestCase {
         XCTAssertNotNil(object4.objectId)
         XCTAssertNotNil(newbornOrphan1.objectId)
         XCTAssertNotNil(newbornOrphan2.objectId)
+        
+        XCTAssertTrue(LCObject.save([]).isSuccess)
     }
 
     func testPrimitiveProperty() {
@@ -240,6 +244,8 @@ class LCObjectTestCase: BaseTestCase {
         XCTAssertEqual(LCError.InternalErrorCode(rawValue: LCObject.fetch([object, newborn]).error!._code), .notFound)
         XCTAssertEqual(LCError.ServerErrorCode(rawValue: LCObject.fetch([object, notFound]).error!._code), .objectNotFound)
         XCTAssertTrue(LCObject.fetch([object, child]).isSuccess)
+        
+        XCTAssertTrue(LCObject.fetch([]).isSuccess)
     }
 
     func testFetchWithKeys() {
@@ -272,7 +278,7 @@ class LCObjectTestCase: BaseTestCase {
         XCTAssertTrue(object.fetch().isFailure)
     }
 
-    func testDeleteAll() {
+    func testDeleteObjects() {
         let object1 = TestObject()
         let object2 = TestObject()
 
@@ -289,6 +295,8 @@ class LCObjectTestCase: BaseTestCase {
         XCTAssertTrue(LCObject.delete([object1, object2]).isSuccess)
         XCTAssertFalse(shadow1.save().isSuccess)
         XCTAssertFalse(shadow2.save().isSuccess)
+        
+        XCTAssertTrue(LCObject.delete([]).isSuccess)
     }
 
     func testKVO() {

Sources/Foundation/ObjectUpdater.swift

@@ -62,44 +62,39 @@ class ObjectUpdater {
         return jsonRequests
     }
 
-    /**
-     Send a list of batch requests synchronously.
-
-     - parameter requests: A list of batch requests.
-     - returns: The response of request.
-     */
-    private static func saveInOneBatchRequest(_ objects: [LCObject], parameters: [String: Any]?, completionInBackground completion: @escaping (LCBooleanResult) -> Void) -> LCRequest {
-        let httpClient: HTTPClient = (objects.first?.application ?? LCApplication.default).httpClient
-        
-        var requests: [Any]
-
-        do {
-            requests = try createSaveBatchRequests(objects: objects, parameters: parameters)
-        } catch let error {
-            return httpClient.request(error: error, completionHandler: completion)
+    private static func saveInOneBatchRequest(
+        _ objects: [LCObject],
+        parameters: [String: Any]?,
+        completionInBackground completion: @escaping (LCBooleanResult) -> Void)
+        -> LCRequest
+    {
+        let httpClient: HTTPClient = (objects.first?.application ?? .default).httpClient
+        guard !objects.isEmpty else {
+            return httpClient.request(object: .success, completionHandler: completion)
         }
-
-        let parameters = ["requests": requests]
-
-        let request = httpClient.request(.post, "batch/save", parameters: parameters) { response in
-            let result = LCBooleanResult(response: response)
-
-            switch result {
-            case .success:
-                updateObjects(objects, response)
-
-                objects.forEach { object in
-                    object.discardChanges()
-                    object.objectDidSave()
+        do {
+            let requests = try createSaveBatchRequests(objects: objects, parameters: parameters)
+            if requests.isEmpty {
+                return httpClient.request(object: .success, completionHandler: completion)
+            } else {
+                return httpClient.request(
+                    .post, "batch/save",
+                    parameters: ["requests": requests])
+                { response in
+                    let result = LCBooleanResult(response: response)
+                    if case .success = result {
+                        self.updateObjects(objects, response)
+                        objects.forEach { object in
+                            object.discardChanges()
+                            object.objectDidSave()
+                        }
+                    }
+                    completion(result)
                 }
-            case .failure:
-                break
             }
-
-            completion(result)
+        } catch {
+            return httpClient.request(error: error, completionHandler: completion)
         }
-
-        return request
     }
 
     /**
@@ -209,37 +204,33 @@ class ObjectUpdater {
 
         return sequenceRequest
     }
-
-    /**
-     Delete a batch of objects in one request synchronously.
-
-     - parameter objects: An array of objects to be deleted.
-
-     - returns: The response of deletion request.
-     */
-    static func delete(_ objects: [LCObject], completionInBackground completion: @escaping (LCBooleanResult) -> Void) -> LCRequest {
-        let httpClient: HTTPClient = (objects.first?.application ?? LCApplication.default).httpClient
-        
-        if objects.isEmpty {
-            return httpClient.request(object: .success) { result in
-                completion(result)
+    
+    static func delete(
+        _ objects: [LCObject],
+        completionInBackground completion: @escaping (LCBooleanResult) -> Void)
+        -> LCRequest
+    {
+        let httpClient: HTTPClient = (objects.first?.application ?? .default).httpClient
+        guard !objects.isEmpty else {
+            return httpClient.request(object: .success, completionHandler: completion)
+        }
+        do {
+            let requests = try objects.unique.map { object in
+                try BatchRequest(object: object, method: .delete)
+                    .jsonValue()
             }
-        } else {
-            var requests: [Any]
-
-            do {
-                requests = try objects.unique.map { object in
-                    try BatchRequest(object: object, method: .delete).jsonValue()
+            if requests.isEmpty {
+                return httpClient.request(object: .success, completionHandler: completion)
+            } else {
+                return httpClient.request(
+                    .post, "batch",
+                    parameters: ["requests": requests])
+                { response in
+                    completion(LCBooleanResult(response: response))
                 }
-            } catch let error {
-                return httpClient.request(error: error, completionHandler: completion)
-            }
-
-            let parameters = ["requests": requests]
-
-            return httpClient.request(.post, "batch", parameters: parameters) { response in
-                completion(LCBooleanResult(response: response))
             }
+        } catch {
+            return httpClient.request(error: error, completionHandler: completion)
         }
     }
 
@@ -305,50 +296,38 @@ class ObjectUpdater {
             return result
         }
     }
-
-    /**
-     Fetch multiple objects in one request synchronously.
-
-     - parameter objects: An array of objects to be fetched.
-
-     - returns: The response of fetching request.
-     */
-    static func fetch(_ objects: [LCObject], keys: [String]?, completionInBackground completion: @escaping (LCBooleanResult) -> Void) -> LCRequest {
-        let httpClient: HTTPClient = (objects.first?.application ?? LCApplication.default).httpClient
-        
-        if objects.isEmpty {
-            return httpClient.request(object: .success) { result in
-                completion(result)
+    
+    static func fetch(
+        _ objects: [LCObject],
+        keys: [String]?,
+        completionInBackground completion: @escaping (LCBooleanResult) -> Void)
+        -> LCRequest
+    {
+        let httpClient: HTTPClient = (objects.first?.application ?? .default).httpClient
+        guard !objects.isEmpty else {
+            return httpClient.request(object: .success, completionHandler: completion)
+        }
+        do {
+            var keysParameters: [String: Any]?
+            if let keys = keys {
+                keysParameters = ["keys": keys.joined(separator: ",")]
             }
-        } else {
-            var requests: [Any]
-
-            do {
-                var onlyIncludeKeys: [String: Any]?
-                if let keys: [String] = keys {
-                    onlyIncludeKeys = ["keys": keys.joined(separator: ",")]
-                }
-                requests = try objects.unique.map { object in
-                    try BatchRequest(object: object, method: .get, parameters: onlyIncludeKeys).jsonValue()
-                }
-            } catch let error {
-                return httpClient.request(error: error, completionHandler: completion)
+            let requests = try objects.unique.map { object in
+                try BatchRequest(object: object, method: .get, parameters: keysParameters)
+                    .jsonValue()
             }
-
-            let parameters = ["requests": requests]
-
-            return httpClient.request(.post, "batch", parameters: parameters) { response in
+            return httpClient.request(
+                .post, "batch",
+                parameters: ["requests": requests])
+            { response in
                 var result = LCBooleanResult(response: response)
-
-                switch result {
-                case .success:
-                    result = handleObjectFetchedResponse(response, objects)
-                case .failure:
-                    break
+                if case .success = result {
+                    result = self.handleObjectFetchedResponse(response, objects)
                 }
-
                 completion(result)
             }
+        } catch {
+            return httpClient.request(error: error, completionHandler: completion)
         }
     }
 }