fix(DataStore): retry initial sync network failures from RemoteSyncEngine (#1773)

* fix(DataStore): retry initial sync network failures from RemoteSyncEngine

* address PR comments

* add functional test

* address PR comment

Author: lawmicha

AmplifyPlugins/DataStore/AWSDataStoreCategoryPlugin/Sync/InitialSync/InitialSyncOrchestrator.swift

@@ -158,10 +158,16 @@ final class AWSInitialSyncOrchestrator: InitialSyncOrchestrator {
             return .successfulVoid
         }
 
+        var underlyingError: Error?
+        if let error = syncErrors.first(where: isNetworkError(_:)) {
+            underlyingError = getUnderlyingNetworkError(error)
+        }
+
         let allMessages = syncErrors.map { String(describing: $0) }
         let syncError = DataStoreError.sync(
             "One or more errors occurred syncing models. See below for detailed error description.",
-            allMessages.joined(separator: "\n")
+            allMessages.joined(separator: "\n"),
+            underlyingError
         )
         return .failure(syncError)
     }
@@ -219,4 +225,36 @@ extension AWSInitialSyncOrchestrator {
         }
         return false
     }
+
+    private func isNetworkError(_ error: DataStoreError) -> Bool {
+        guard case let .sync(_, _, underlyingError) = error,
+              let datastoreError = underlyingError as? DataStoreError
+              else {
+            return false
+        }
+
+        if case let .api(amplifyError, _) = datastoreError,
+           let apiError = amplifyError as? APIError,
+           case .networkError = apiError {
+            return true
+        }
+
+        return false
+    }
+
+    private func getUnderlyingNetworkError(_ error: DataStoreError) -> Error? {
+        guard case let .sync(_, _, underlyingError) = error,
+              let datastoreError = underlyingError as? DataStoreError
+              else {
+            return nil
+        }
+
+        if case let .api(amplifyError, _) = datastoreError,
+           let apiError = amplifyError as? APIError,
+           case let .networkError(_, _, underlyingError) = apiError {
+            return underlyingError
+        }
+
+        return nil
+    }
 }

AmplifyPlugins/DataStore/AWSDataStoreCategoryPlugin/Sync/RemoteSyncEngine+Retryable.swift

@@ -30,10 +30,15 @@ extension RemoteSyncEngine {
     }
 
     private func getRetryAdvice(error: Error) -> RequestRetryAdvice {
-        //TODO: Parse error from the receive completion to use as an input into getting retry advice.
-        //      For now, specifying not connected to internet to force a retry up to our maximum
-        let urlError = URLError(.notConnectedToInternet)
-        let advice = requestRetryablePolicy.retryRequestAdvice(urlError: urlError,
+        var urlErrorOptional: URLError?
+        if let dataStoreError = error as? DataStoreError,
+            let underlyingError = dataStoreError.underlyingError as? URLError {
+            urlErrorOptional = underlyingError
+        } else if let urlError = error as? URLError {
+            urlErrorOptional = urlError
+        }
+
+        let advice = requestRetryablePolicy.retryRequestAdvice(urlError: urlErrorOptional,
                                                                httpURLResponse: nil,
                                                                attemptNumber: currentAttemptNumber)
         return advice

AmplifyPlugins/DataStore/AWSDataStoreCategoryPluginTests/Sync/RemoteSyncEngineTests.swift

@@ -72,11 +72,15 @@ class RemoteSyncEngineTests: XCTestCase {
         let subscriptionsEstablishedReceived = expectation(description: "subscriptionsEstablished received")
         let cleanedup = expectation(description: "cleanedup")
         let failureOnInitialSync = expectation(description: "failureOnInitialSync")
-
+        let retryAdviceReceivedNetworkError = expectation(description: "retry advice received network error")
         var currCount = 1
 
         let advice = RequestRetryAdvice.init(shouldRetry: false)
         mockRequestRetryablePolicy.pushOnRetryRequestAdvice(response: advice)
+        mockRequestRetryablePolicy.setOnRetryRequestAdvice { urlError, httpURLResponse, attemptNumber in
+            XCTAssertNotNil(urlError)
+            retryAdviceReceivedNetworkError.fulfill()
+        }
 
         let filter = HubFilters.forEventName(HubPayload.EventName.DataStore.subscriptionsEstablished)
         let hubListener = Amplify.Hub.listen(to: .dataStore, isIncluded: filter) { payload in
@@ -116,8 +120,8 @@ class RemoteSyncEngineTests: XCTestCase {
                     XCTFail("Unexpected case gets hit")
                 }
             })
-        MockAWSInitialSyncOrchestrator.setResponseOnSync(result:
-            .failure(DataStoreError.internalOperation("forceError", "none", nil)))
+        MockAWSInitialSyncOrchestrator.setResponseOnSync(result: .failure(
+            DataStoreError.internalOperation("forceError", "none", URLError(.notConnectedToInternet))))
 
         remoteSyncEngine.start(api: apiPlugin)
 
@@ -128,7 +132,8 @@ class RemoteSyncEngineTests: XCTestCase {
                    subscriptionsInitialized,
                    subscriptionsEstablishedReceived,
                    cleanedup,
-                   failureOnInitialSync], timeout: defaultAsyncWaitTimeout)
+                   failureOnInitialSync,
+                   retryAdviceReceivedNetworkError], timeout: defaultAsyncWaitTimeout)
         remoteSyncEngineSink.cancel()
         Amplify.Hub.removeListener(hubListener)
     }

AmplifyPlugins/DataStore/AWSDataStoreCategoryPluginTests/TestSupport/Mocks/MockRequestRetryablePolicy.swift

@@ -15,15 +15,21 @@ import Foundation
 class MockRequestRetryablePolicy: RequestRetryablePolicy {
 
     var responseQueue: [RequestRetryAdvice] = []
+    var onRetryRequestAdvice: ((URLError?, HTTPURLResponse?, Int) -> Void)?
 
     func pushOnRetryRequestAdvice(response: RequestRetryAdvice) {
         responseQueue.append(response)
     }
 
+    func setOnRetryRequestAdvice(onRetryRequestAdvice: @escaping (URLError?, HTTPURLResponse?, Int) -> Void) {
+        self.onRetryRequestAdvice = onRetryRequestAdvice
+    }
+
     override func retryRequestAdvice(urlError: URLError?,
                                      httpURLResponse: HTTPURLResponse?,
                                      attemptNumber: Int) -> RequestRetryAdvice {
+        onRetryRequestAdvice?(urlError, httpURLResponse, attemptNumber)
         // If this breaks, you didn't push anything onto the queue
-        responseQueue.removeFirst()
+        return responseQueue.removeFirst()
     }
 }