test(DataStore): Integration tests for consecutive updates - save then multiple updates scenario (#1455)

* test(DataStore): Integration tests for consecutive updates - save then multiple updates scenario

* Address review comments

Author: thisisabhash

AmplifyPlugins/DataStore/AWSDataStoreCategoryPluginIntegrationTests/DataStoreConsecutiveUpdatesTests.swift

@@ -368,6 +368,123 @@ class DataStoreConsecutiveUpdatesTests: SyncEngineIntegrationTestBase {
         wait(for: [apiQuerySuccess], timeout: networkTimeout)
     }
 
+    /// - Given: API has been setup with `Post` model registered
+    /// - When: A Post is saved with sync complete, then it is updated 10 times
+    /// - Then: The Post should be updated with new fields
+    func testSaveThenMultipleUpdate() throws {
+        try startAmplifyAndWaitForSync()
+
+        let newPost = Post(title: "MyPost",
+                          content: "This is my post.",
+                          createdAt: .now(),
+                          rating: 3,
+                          status: .published)
+        var updatedPost = newPost
+        let updatedPostDefaultTitle = "MyUpdatedPost"
+        let updateCount = 10
+
+        let saveSyncReceived = expectation(description: "Received create mutation event on subscription for Post")
+        let updateSyncReceived = expectation(description: "Received update mutation event on subscription for Post")
+
+        let hubListener = Amplify.Hub.listen(
+            to: .dataStore,
+            eventName: HubPayload.EventName.DataStore.syncReceived) { payload in
+            guard let mutationEvent = payload.data as? MutationEvent else {
+                XCTFail("Can't cast payload as mutation event")
+                return
+            }
+
+            guard let post = try? mutationEvent.decodeModel() as? Post, post.id == newPost.id else {
+                return
+            }
+
+            if mutationEvent.mutationType == GraphQLMutationType.create.rawValue {
+                XCTAssertEqual(post, newPost)
+                XCTAssertEqual(mutationEvent.version, 1)
+                saveSyncReceived.fulfill()
+                return
+            }
+
+            if mutationEvent.mutationType == GraphQLMutationType.update.rawValue {
+                if post.title == updatedPostDefaultTitle + String(updateCount) {
+                    updateSyncReceived.fulfill()
+                    return
+                }
+            }
+
+        }
+
+        guard try HubListenerTestUtilities.waitForListener(with: hubListener, timeout: 5.0) else {
+            XCTFail("Listener not registered for hub")
+            return
+        }
+
+        let saveCompleted = expectation(description: "Save is completed")
+        Amplify.DataStore.save(newPost) { result in
+            switch result {
+            case .success:
+                saveCompleted.fulfill()
+            case .failure(let error):
+                XCTFail("Error: \(error)")
+            }
+        }
+        wait(for: [saveCompleted, saveSyncReceived], timeout: networkTimeout)
+
+        for index in 1 ... updateCount {
+            updatedPost.title = updatedPostDefaultTitle + String(index)
+            let saveExpectation = expectation(description: "Save \(index) is successful")
+            Amplify.DataStore.save(updatedPost) { result in
+                switch result {
+                case .success:
+                    saveExpectation.fulfill()
+                case .failure(let error):
+                    XCTFail("Error: \(error)")
+                }
+            }
+            wait(for: [saveExpectation], timeout: networkTimeout)
+        }
+
+        wait(for: [updateSyncReceived], timeout: networkTimeout)
+
+        // query the updated post in eventual consistent state
+        guard let queryResultAfterSync = queryPost(byId: updatedPost.id) else {
+            XCTFail("Post should be available after update and sync")
+            return
+        }
+
+        XCTAssertEqual(queryResultAfterSync, updatedPost)
+
+        let queryRequest =
+            GraphQLRequest<MutationSyncResult?>.query(modelName: updatedPost.modelName, byId: updatedPost.id)
+        let apiQuerySuccess = expectation(description: "API query is successful")
+        Amplify.API.query(request: queryRequest) { result in
+            switch result {
+            case .success(let mutationSyncResult):
+                switch mutationSyncResult {
+                case .success(let data):
+                    guard let post = data else {
+                        XCTFail("Failed to get data")
+                        return
+                    }
+
+                    XCTAssertEqual(post.model["title"] as? String, updatedPost.title)
+                    XCTAssertEqual(post.model["content"] as? String, updatedPost.content)
+                    XCTAssertEqual(post.model["rating"] as? Double, updatedPost.rating)
+                    // version can be anything between 3 to 11 depending on how many
+                    // pending mutations are overwritten in pending mutation queue
+                    // while the first update mutation is being processed
+                    XCTAssertTrue(post.syncMetadata.version >= 3 && post.syncMetadata.version <= 11)
+                    apiQuerySuccess.fulfill()
+                case .failure(let error):
+                    XCTFail("Error: \(error)")
+                }
+            case .failure(let error):
+                XCTFail("Error: \(error)")
+            }
+        }
+        wait(for: [apiQuerySuccess], timeout: networkTimeout)
+    }
+
     private func queryPost(byId id: String) -> Post? {
         let queryExpectation = expectation(description: "Query is successful")
         var queryResult: Post?