ErrorUtils.purchasesError(withSKError:): handle URLErrors

Sources/Error Handling/ErrorUtils.swift

@@ -288,6 +288,15 @@ enum ErrorUtils {
             return skError.asPurchasesError
         case let purchasesError as PurchasesError:
             return purchasesError
+        case is URLError:
+            // Some StoreKit APIs can return `URLError`s.
+            // See https://github.com/RevenueCat/purchases-ios/issues/3343
+            return NetworkError.networkError(
+                error as NSError,
+                .init(file: fileName,
+                      function: functionName,
+                      line: line)
+            ).asPurchasesError
         default:
             return ErrorUtils.unknownError(
                 error: error,

Sources/Networking/HTTPClient/HTTPClient.swift

@@ -527,14 +527,7 @@ private extension NetworkError {
             Logger.error(blockedError.description)
             self = blockedError
         } else {
-            let nsError = error as NSError
-
-            switch (nsError.domain, nsError.code) {
-            case (NSURLErrorDomain, NSURLErrorNotConnectedToInternet):
-                self = .offlineConnection()
-            default:
-                self = .networkError(error)
-            }
+            self = .networkError(error as NSError)
         }
     }
 

Sources/Networking/HTTPClient/NetworkError.swift

@@ -19,7 +19,6 @@ import Foundation
 enum NetworkError: Swift.Error, Equatable {
 
     case decoding(NSError, Source)
-    case offlineConnection(Source)
     case networkError(NSError, Source)
     case dnsError(failedURL: URL, resolvedHost: String?, Source)
     case unableToCreateRequest(path: String, Source)
@@ -45,12 +44,6 @@ extension NetworkError {
         return .decoding(error as NSError, .init(file: file, function: function, line: line))
     }
 
-    static func offlineConnection(
-        file: String = #fileID, function: String = #function, line: UInt = #line
-    ) -> Self {
-        return .offlineConnection(.init(file: file, function: function, line: line))
-    }
-
     static func networkError(
         _ error: Error,
         file: String = #fileID, function: String = #function, line: UInt = #line
@@ -113,7 +106,8 @@ extension NetworkError: PurchasesErrorConvertible {
                 line: source.line
             )
 
-        case let .offlineConnection(source):
+        case let .networkError(error, source)
+            where error.domain == NSURLErrorDomain && error.code == NSURLErrorNotConnectedToInternet:
             return ErrorUtils.offlineConnectionError(
                 fileName: source.file,
                 functionName: source.function,
@@ -183,7 +177,8 @@ extension NetworkError: DescribableError {
         case let .decoding(error, _):
             return error.localizedDescription
 
-        case .offlineConnection:
+        case let .networkError(error, _)
+            where error.domain == NSURLErrorDomain && error.code == NSURLErrorNotConnectedToInternet:
             return ErrorCode.offlineConnectionError.description
 
         case let .networkError(error, _):
@@ -240,8 +235,7 @@ extension NetworkError {
         case let .errorResponse(_, statusCode, _):
             return statusCode
 
-        case .offlineConnection,
-             .decoding,
+        case .decoding,
              .networkError,
              .dnsError,
              .unableToCreateRequest,

Tests/UnitTests/Networking/HTTPClientTests.swift

@@ -1282,6 +1282,7 @@ final class HTTPClientTests: BaseHTTPClientTests<MockETagManager> {
         let path: HTTPRequest.Path = .mockPath
 
         let error = NSError(domain: NSURLErrorDomain, code: NSURLErrorNotConnectedToInternet)
+        let expectedError: NetworkError = .networkError(error)
 
         stub(condition: isPath(path)) { _ in
             let response = HTTPStubsResponse.emptySuccessResponse()
@@ -1295,8 +1296,9 @@ final class HTTPClientTests: BaseHTTPClientTests<MockETagManager> {
             }
         }
 
-        expect(obtainedError).toNot(beNil())
-        expect(obtainedError) == .offlineConnection()
+        // Can't compare the errors directly because `obtainedError` has additional userInfo.
+        expect(obtainedError?.asPurchasesError)
+            .to(matchError(expectedError.asPurchasesError))
     }
 
     func testErrorIsLoggedAndReturnsDNSErrorWhenGETRequestFailedWithDNSError() {

Tests/UnitTests/Networking/NetworkErrorTests.swift

@@ -381,4 +381,15 @@ extension NetworkError {
         )
     }
 
+    static func offlineConnection(
+        file: String = #fileID, function: String = #function, line: UInt = #line
+    ) -> Self {
+        return .networkError(
+            NSError(domain: NSURLErrorDomain, code: NSURLErrorNotConnectedToInternet),
+            file: file,
+            function: function,
+            line: line
+        )
+    }
+
 }

Tests/UnitTests/Paywalls/Events/PaywallEventsManagerTests.swift

@@ -126,12 +126,13 @@ class PaywallEventsManagerTests: TestCase {
     func testFlushWithUnsuccessfulPostError() async throws {
         let event = await self.storeRandomEvent()
         let storedEvent: PaywallStoredEvent = .init(event: event, userID: Self.userID)
+        let expectedError: NetworkError = .offlineConnection()
 
-        self.api.stubbedPostPaywallEventsCompletionResult = .networkError(.offlineConnection())
+        self.api.stubbedPostPaywallEventsCompletionResult = .networkError(expectedError)
         do {
             _ = try await self.manager.flushEvents(count: 1)
             fail("Expected error")
-        } catch BackendError.networkError(.offlineConnection) {
+        } catch BackendError.networkError(expectedError) {
             // Expected
         } catch {
             throw error

Tests/UnitTests/Purchasing/ErrorUtilsTests.swift

@@ -136,6 +136,14 @@ class ErrorUtilsTests: TestCase {
             .to(matchError(error))
     }
 
+    func testPurchasesErrorWithNetworkErrorAsSKError() {
+        let error = NSError(domain: NSURLErrorDomain, code: NSURLErrorNotConnectedToInternet)
+        let expectedError = ErrorUtils.offlineConnectionError()
+
+        expect(ErrorUtils.purchasesError(withSKError: error))
+            .to(matchError(expectedError))
+    }
+
     func testPurchaseErrorsAreLoggedAsApppleErrors() {
         let underlyingError = NSError(domain: SKErrorDomain, code: SKError.Code.paymentInvalid.rawValue)
         let error = ErrorUtils.purchaseNotAllowedError(error: underlyingError)