fix: restore name after updating ParseRole (#10)

* fix: restore name after updating ParseRole

* nit

Author: cbaker6

CHANGELOG.md

@@ -7,6 +7,9 @@
 __New features__
 - Added the ability to check if a `ParseObject` key is dirty ([#9](https://github.com/netreconlab/Parse-Swift/pull/9)), thanks to [Corey Baker](https://github.com/cbaker6).
 
+__Fixes__
+- Fixed an issue where the name propery of a ParseRole may not be restored after updating a ParseRole on the server ([#10](https://github.com/netreconlab/Parse-Swift/pull/10)), thanks to [Corey Baker](https://github.com/cbaker6).
+
 ### 4.15.2
 [Full Changelog](https://github.com/netreconlab/Parse-Swift/compare/4.15.1...4.15.2), [Documentation](https://swiftpackageindex.com/netreconlab/Parse-Swift/4.15.2/documentation/parseswift)
 

ParseSwift.playground/Pages/12 - Roles and Relations.xcplaygroundpage/Contents.swift

@@ -58,15 +58,18 @@ struct Role<RoleUser: ParseUser>: ParseRole {
     //: Provided by Role.
     var name: String?
 
+    //: Custom properties.
+    var subtitle: String
+
     /*:
      Optional - implement your own version of merge
      for faster decoding after updating your `ParseObject`.
      */
     func merge(with object: Self) throws -> Self {
         var updated = try mergeParse(with: object)
-        if updated.shouldRestoreKey(\.name,
+        if updated.shouldRestoreKey(\.subtitle,
                                      original: object) {
-            updated.name = object.name
+            updated.subtitle = object.subtitle
         }
         return updated
     }
@@ -124,7 +127,8 @@ acl.setWriteAccess(user: currentUser, value: true)
 
 do {
     //: Create the actual Role with a name and ACL.
-    let adminRole = try Role<User>(name: "Administrator", acl: acl)
+    var adminRole = try Role<User>(name: "Administrator", acl: acl)
+    adminRole.subtitle = "staff"
     adminRole.save { result in
         switch result {
         case .success(let saved):
@@ -166,7 +170,10 @@ do {
     print("Error: \(error)")
 }
 
-//: To retrieve the users who are all Administrators, we need to query the relation.
+/*:
+ To retrieve the users who are all Administrators,
+ we need to query the relation.
+ */
 do {
     let query: Query<User>? = try savedRole!.users?.query()
     query?.find { result in
@@ -201,8 +208,10 @@ do {
     print(error)
 }
 
-//: Additional roles can be created and tied to already created roles. Lets create a "Member" role.
-
+/*:
+ Additional roles can be created and tied to already created roles.
+ Lets create a "Member" role.
+*/
 //: This variable will store the saved role.
 var savedRoleModerator: Role<User>?
 
@@ -233,8 +242,12 @@ if savedRoleModerator != nil {
 
 //: Roles can be added to our previously saved Role.
 do {
-    //: `ParseRoles` have `ParseRelations` that relate them either `ParseUser` and `ParseRole` objects.
-    //: The `ParseUser` relations can be accessed using `users`. We can then add `ParseUser`'s to the relation.
+    /*:
+     `ParseRoles` have `ParseRelations` that relate them either
+     `ParseUser` and `ParseRole` objects. The `ParseUser`
+     relations can be accessed using `users`. We can then add
+     `ParseUser`'s to the relation.
+     */
     try savedRole!.roles?.add([savedRoleModerator!]).save { result in
         switch result {
         case .success(let saved):
@@ -249,8 +262,11 @@ do {
     print("Error: \(error)")
 }
 
-//: To retrieve the users who are all Administrators, we need to query the relation.
-//: This time we will use a helper query from `ParseRole`.
+/*:
+ To retrieve the users who are all Administrators,
+ we need to query the relation. This time we will
+ use a helper query from `ParseRole`.
+ */
 do {
     try savedRole!.queryRoles().find { result in
         switch result {
@@ -284,10 +300,12 @@ do {
     print(error)
 }
 
-//: Using this relation, you can create one-to-many relationships with other `ParseObjecs`,
-//: similar to `users` and `roles`.
-//: All `ParseObject`s have a `ParseRelation` attribute that be used on instances.
-//: For example, the User has:
+/*:
+ Using this relation, you can create one-to-many relationships
+ with other `ParseObjecs`, similar to `users` and `roles`. All
+ `ParseObject`s have a `ParseRelation` attribute that be used on
+ instances. For example, the User has:
+ */
 var relation = User.current!.relation
 let score1 = GameScore(points: 53)
 let score2 = GameScore(points: 57)

ParseSwift.playground/Pages/5 - ACL.xcplaygroundpage/Contents.swift

@@ -60,9 +60,10 @@ extension GameScore {
 //: Define initial GameScores.
 var score = GameScore(points: 40)
 
-/*: Save asynchronously (preferred way) - Performs work on background
-    queue and returns to specified callbackQueue.
-    If no callbackQueue is specified it returns to main queue.
+/*:
+ Save asynchronously (preferred way) - Performs work on background
+ queue and returns to specified callbackQueue. If no callbackQueue
+ is specified it returns to main queue.
 */
 score.save { result in
     switch result {

Sources/ParseSwift/Objects/ParseRole.swift

@@ -101,6 +101,31 @@ public extension ParseRole {
         let name = self.name ?? self.objectId
         hasher.combine(name)
     }
+
+    func mergeParse(with object: Self) throws -> Self {
+        guard hasSameObjectId(as: object) else {
+            throw ParseError(code: .unknownError,
+                             message: "objectId's of objects do not match")
+        }
+        var updatedRole = self
+        if shouldRestoreKey(\.ACL,
+                             original: object) {
+            updatedRole.ACL = object.ACL
+        }
+        if shouldRestoreKey(\.name,
+                             original: object) {
+            updatedRole.name = object.name
+        }
+        return updatedRole
+    }
+
+    func merge(with object: Self) throws -> Self {
+        do {
+            return try mergeAutomatically(object)
+        } catch {
+            return try mergeParse(with: object)
+        }
+    }
 }
 
 // MARK: Convenience

Tests/ParseSwiftTests/ParseRoleTests.swift

@@ -65,6 +65,18 @@ class ParseRoleTests: XCTestCase {
 
         // provided by Role
         var name: String?
+
+        // custom
+        var title: String?
+
+        func merge(with object: Self) throws -> Self {
+            var updated = try mergeParse(with: object)
+            if updated.shouldRestoreKey(\.title,
+                                         original: object) {
+                updated.title = object.title
+            }
+            return updated
+        }
     }
 
     struct Level: ParseObject {
@@ -131,6 +143,49 @@ class ParseRoleTests: XCTestCase {
         XCTAssertEqual(role.endpoint.urlComponent, "/roles/me")
     }
 
+    func testSaveUpdateCommandParseObjectMutable() throws {
+        var role = try Role<User>(name: "Administrator")
+        let className = role.className
+        let objectId = "yarr"
+        role.objectId = objectId
+        role.createdAt = Date()
+        role.updatedAt = role.createdAt
+
+        let command = try role.mergeable.saveCommand()
+        XCTAssertNotNil(command)
+        XCTAssertEqual(command.path.urlComponent, "/classes/\(className)/\(objectId)")
+        XCTAssertEqual(command.method, API.Method.PUT)
+        XCTAssertNil(command.params)
+
+        guard let body = command.body else {
+            XCTFail("Should be able to unwrap")
+            return
+        }
+
+        let expected = "{}"
+        let encoded = try ParseCoding.parseEncoder()
+            .encode(body, collectChildren: false,
+                    objectsSavedBeforeThisOne: nil,
+                    filesSavedBeforeThisOne: nil).encoded
+        let decoded = try XCTUnwrap(String(data: encoded, encoding: .utf8))
+        XCTAssertEqual(decoded, expected)
+
+        var empty = role.mergeable
+        empty.title = "hello"
+        let command2 = try empty.saveCommand()
+        guard let body2 = command2.body else {
+            XCTFail("Should be able to unwrap")
+            return
+        }
+        let expected2 = "{\"title\":\"hello\"}"
+        let encoded2 = try ParseCoding.parseEncoder()
+            .encode(body2, collectChildren: false,
+                    objectsSavedBeforeThisOne: nil,
+                    filesSavedBeforeThisOne: nil).encoded
+        let decoded2 = try XCTUnwrap(String(data: encoded2, encoding: .utf8))
+        XCTAssertEqual(decoded2, expected2)
+    }
+
     func testUserAddIncorrectClassKeyError() throws {
         var acl = ParseACL()
         acl.publicWrite = false
@@ -419,6 +474,52 @@ class ParseRoleTests: XCTestCase {
         XCTAssertTrue(updatedRole.hasSameObjectId(as: serverResponse))
     }
 
+    func testRoleUpdateMergeSynchronous() throws {
+        var acl = ParseACL()
+        acl.publicWrite = false
+        acl.publicRead = true
+
+        var role = try Role<User>(name: "Administrator", acl: acl)
+        role.createdAt = Date()
+        role.updatedAt = Date()
+        role.title = "hello"
+        XCTAssertNil(role.roles) // Should not produce a relation without an objectId.
+        role.objectId = "yolo"
+        guard role.roles != nil else {
+            XCTFail("Should have unwrapped")
+            return
+        }
+
+        var newRole = try Role<User>(name: "Moderator", acl: acl)
+        newRole.objectId = "heel"
+
+        var serverResponse = role
+        serverResponse.createdAt = nil
+        serverResponse.updatedAt = Date()
+
+        let encoded: Data!
+        do {
+            encoded = try ParseCoding.jsonEncoder().encode(serverResponse)
+            //Get dates in correct format from ParseDecoding strategy
+            serverResponse = try serverResponse.getDecoder().decode(Role<User>.self, from: encoded)
+        } catch {
+            XCTFail("Should encode/decode. Error \(error)")
+            return
+        }
+
+        MockURLProtocol.mockRequests { _ in
+            return MockURLResponse(data: encoded, statusCode: 200, delay: 0.0)
+        }
+
+        var changedRole = role
+            .set(\.title, to: "peace")
+        let updatedRole = try changedRole.save()
+        XCTAssertEqual(updatedRole.updatedAt, serverResponse.updatedAt)
+        XCTAssertEqual(updatedRole.name, serverResponse.name)
+        XCTAssertEqual(updatedRole.title, changedRole.title)
+        XCTAssertTrue(updatedRole.hasSameObjectId(as: serverResponse))
+    }
+
     func testRoleAddOperationSaveSynchronousError() throws {
         var acl = ParseACL()
         acl.publicWrite = false