Fix default error handling for subscribe(with:)

RxSwift/ObservableType+Extensions.swift

@@ -51,9 +51,11 @@ public extension ObservableType {
                 guard let object else { return }
                 onNext?(object, $0)
             },
-            onError: { [weak object] in
-                guard let object else { return }
-                onError?(object, $0)
+            onError: onError.map { onError in
+                { [weak object] in
+                    guard let object else { return }
+                    onError(object, $0)
+                }
             },
             onCompleted: { [weak object] in
                 guard let object else { return }

RxSwift/Traits/PrimitiveSequence/Completable.swift

@@ -95,9 +95,11 @@ public extension PrimitiveSequenceType where Trait == CompletableTrait, Element
             onCompleted: { [weak object] in
                 guard let object else { return }
                 onCompleted?(object)
-            }, onError: { [weak object] in
-                guard let object else { return }
-                onError?(object, $0)
+            }, onError: onError.map { onError in
+                { [weak object] in
+                    guard let object else { return }
+                    onError(object, $0)
+                }
             }, onDisposed: { [weak object] in
                 guard let object else { return }
                 onDisposed?(object)

RxSwift/Traits/PrimitiveSequence/Maybe.swift

@@ -104,9 +104,11 @@ public extension PrimitiveSequenceType where Trait == MaybeTrait {
                 guard let object else { return }
                 onSuccess?(object, $0)
             },
-            onError: { [weak object] in
-                guard let object else { return }
-                onError?(object, $0)
+            onError: onError.map { onError in
+                { [weak object] in
+                    guard let object else { return }
+                    onError(object, $0)
+                }
             },
             onCompleted: { [weak object] in
                 guard let object else { return }

RxSwift/Traits/PrimitiveSequence/Single.swift

@@ -108,9 +108,11 @@ public extension PrimitiveSequenceType where Trait == SingleTrait {
                 guard let object else { return }
                 onSuccess?(object, $0)
             },
-            onFailure: { [weak object] in
-                guard let object else { return }
-                onFailure?(object, $0)
+            onFailure: onFailure.map { onFailure in
+                { [weak object] in
+                    guard let object else { return }
+                    onFailure(object, $0)
+                }
             },
             onDisposed: { [weak object] in
                 guard let object else { return }

Sources/AllTestz/main.swift

@@ -179,6 +179,7 @@ final class CompletableTest_ : CompletableTest, RxTestCase {
     ("test_zip_array", CompletableTest.test_zip_array),
     ("test_zip_variadic", CompletableTest.test_zip_variadic),
     ("testDefaultErrorHandler", CompletableTest.testDefaultErrorHandler),
+    ("testDefaultErrorHandlerWithObject", CompletableTest.testDefaultErrorHandlerWithObject),
     ] }
 }
 
@@ -436,6 +437,7 @@ final class MaybeTest_ : MaybeTest, RxTestCase {
     ("test_zip_tuple", MaybeTest.test_zip_tuple),
     ("test_zip_resultSelector", MaybeTest.test_zip_resultSelector),
     ("testDefaultErrorHandler", MaybeTest.testDefaultErrorHandler),
+    ("testDefaultErrorHandlerWithObject", MaybeTest.testDefaultErrorHandlerWithObject),
     ("testZip2_selector", MaybeTest.testZip2_selector),
     ("testZip2_tuple", MaybeTest.testZip2_tuple),
     ("testZip3_selector", MaybeTest.testZip3_selector),
@@ -1496,6 +1498,7 @@ final class ObservableSubscriptionTest_ : ObservableSubscriptionTest, RxTestCase
 
     static var allTests: [(String, (ObservableSubscriptionTest_) -> () -> Void)] { return [
     ("testDefaultErrorHandler", ObservableSubscriptionTest.testDefaultErrorHandler),
+    ("testDefaultErrorHandlerWithObject", ObservableSubscriptionTest.testDefaultErrorHandlerWithObject),
     ("testCustomCaptureSubscriptionCallstack", ObservableSubscriptionTest.testCustomCaptureSubscriptionCallstack),
     ] }
 }
@@ -2175,6 +2178,7 @@ final class SingleTest_ : SingleTest, RxTestCase {
     ("testZipCollection_tuple", SingleTest.testZipCollection_tuple),
     ("testZipCollection_tuple_when_empty", SingleTest.testZipCollection_tuple_when_empty),
     ("testDefaultErrorHandler", SingleTest.testDefaultErrorHandler),
+    ("testDefaultErrorHandlerWithObject", SingleTest.testDefaultErrorHandlerWithObject),
     ] }
 }
 

Tests/RxSwiftTests/CompletableTest.swift

@@ -601,6 +601,28 @@ extension CompletableTest {
         _ = Completable.error(testError).subscribe()
         XCTAssertEqual(loggedErrors, [testError])
     }
+
+    func testDefaultErrorHandlerWithObject() {
+        var loggedErrors = [TestError]()
+        var handledErrors = [TestError]()
+        let originalErrorHandler = Hooks.defaultErrorHandler
+        defer { Hooks.defaultErrorHandler = originalErrorHandler }
+
+        Hooks.defaultErrorHandler = { _, error in
+            loggedErrors.append(error as! TestError)
+        }
+
+        _ = Completable.error(testError).subscribe(with: self, onError: { _, error in
+            handledErrors.append(error as! TestError)
+        })
+
+        XCTAssertEqual(handledErrors, [testError])
+        XCTAssertEqual(loggedErrors, [])
+
+        _ = Completable.error(testError).subscribe(with: self)
+
+        XCTAssertEqual(loggedErrors, [testError])
+    }
 }
 
 public func == (_: Never, _: Never) -> Bool {}

Tests/RxSwiftTests/MaybeTest.swift

@@ -774,4 +774,26 @@ extension MaybeTest {
         _ = Maybe<Int>.error(testError).subscribe()
         XCTAssertEqual(loggedErrors, [testError])
     }
+
+    func testDefaultErrorHandlerWithObject() {
+        var loggedErrors = [TestError]()
+        var handledErrors = [TestError]()
+        let originalErrorHandler = Hooks.defaultErrorHandler
+        defer { Hooks.defaultErrorHandler = originalErrorHandler }
+
+        Hooks.defaultErrorHandler = { _, error in
+            loggedErrors.append(error as! TestError)
+        }
+
+        _ = Maybe<Int>.error(testError).subscribe(with: self, onError: { _, error in
+            handledErrors.append(error as! TestError)
+        })
+
+        XCTAssertEqual(handledErrors, [testError])
+        XCTAssertEqual(loggedErrors, [])
+
+        _ = Maybe<Int>.error(testError).subscribe(with: self)
+
+        XCTAssertEqual(loggedErrors, [testError])
+    }
 }

Tests/RxSwiftTests/ObservableType+SubscriptionTests.swift

@@ -34,8 +34,38 @@ extension ObservableSubscriptionTest {
         XCTAssertEqual(loggedErrors, [testError])
     }
 
+    func testDefaultErrorHandlerWithObject() {
+        var loggedErrors = [TestError]()
+        var handledErrors = [TestError]()
+        let originalErrorHandler = Hooks.defaultErrorHandler
+        defer { Hooks.defaultErrorHandler = originalErrorHandler }
+
+        Hooks.defaultErrorHandler = { _, error in
+            loggedErrors.append(error as! TestError)
+        }
+
+        _ = Observable<Int>.error(testError).subscribe(with: self, onError: { _, error in
+            handledErrors.append(error as! TestError)
+        })
+
+        XCTAssertEqual(handledErrors, [testError])
+        XCTAssertEqual(loggedErrors, [])
+
+        _ = Observable<Int>.error(testError).subscribe(with: self)
+
+        XCTAssertEqual(loggedErrors, [testError])
+    }
+
     func testCustomCaptureSubscriptionCallstack() {
         var resultCallstack = [String]()
+        let originalErrorHandler = Hooks.defaultErrorHandler
+        let originalCaptureSubscriptionCallstack = Hooks.customCaptureSubscriptionCallstack
+        let originalRecordCallStackOnError = Hooks.recordCallStackOnError
+        defer {
+            Hooks.defaultErrorHandler = originalErrorHandler
+            Hooks.customCaptureSubscriptionCallstack = originalCaptureSubscriptionCallstack
+            Hooks.recordCallStackOnError = originalRecordCallStackOnError
+        }
 
         Hooks.defaultErrorHandler = { callstack, _ in
             resultCallstack = callstack

Tests/RxSwiftTests/SingleTest.swift

@@ -780,4 +780,26 @@ extension SingleTest {
         _ = Single<Int>.error(testError).subscribe()
         XCTAssertEqual(loggedErrors, [testError])
     }
+
+    func testDefaultErrorHandlerWithObject() {
+        var loggedErrors = [TestError]()
+        var handledErrors = [TestError]()
+        let originalErrorHandler = Hooks.defaultErrorHandler
+        defer { Hooks.defaultErrorHandler = originalErrorHandler }
+
+        Hooks.defaultErrorHandler = { _, error in
+            loggedErrors.append(error as! TestError)
+        }
+
+        _ = Single<Int>.error(testError).subscribe(with: self, onFailure: { _, error in
+            handledErrors.append(error as! TestError)
+        })
+
+        XCTAssertEqual(handledErrors, [testError])
+        XCTAssertEqual(loggedErrors, [])
+
+        _ = Single<Int>.error(testError).subscribe(with: self)
+
+        XCTAssertEqual(loggedErrors, [testError])
+    }
 }