Merge branch 'TheAdamBorek-fix/1252_driver_scheduling' into develop

kzaher · kzaher · commit f74657cf0e56 · 2017-05-20T15:21:46.000+02:00
diff --git a/RxCocoa/Traits/Driver/Driver.swift b/RxCocoa/Traits/Driver/Driver.swift
@@ -37,7 +37,7 @@
 public typealias Driver<E> = SharedSequence<DriverSharingStrategy, E>
 
 public struct DriverSharingStrategy: SharingStrategyProtocol {
-    public static var scheduler: SchedulerType { return driverObserveOnScheduler }
+    public static var scheduler: SchedulerType { return driverObserveOnScheduler() }
     public static func share<E>(_ source: Observable<E>) -> Observable<E> {
         return source.shareReplayLatestWhileConnected()
     }
@@ -58,12 +58,12 @@ extension SharedSequenceConvertibleType where SharingStrategy == DriverSharingSt
 */
 public func driveOnScheduler(_ scheduler: SchedulerType, action: () -> ()) {
     let originalObserveOnScheduler = driverObserveOnScheduler
-    driverObserveOnScheduler = scheduler
+    driverObserveOnScheduler = { return scheduler }
 
     action()
 
     // If you remove this line , compiler buggy optimizations will change behavior of this code
-    _forceCompilerToStopDoingInsaneOptimizationsThatBreakCode(driverObserveOnScheduler)
+    _forceCompilerToStopDoingInsaneOptimizationsThatBreakCode(scheduler)
     // Scary, I know
 
     driverObserveOnScheduler = originalObserveOnScheduler
@@ -87,4 +87,4 @@ func _forceCompilerToStopDoingInsaneOptimizationsThatBreakCode(_ scheduler: Sche
     }
 }
 
-fileprivate var driverObserveOnScheduler: SchedulerType = MainScheduler.instance
+fileprivate var driverObserveOnScheduler: () -> SchedulerType = { MainScheduler() }
diff --git a/Sources/AllTestz/main.swift b/Sources/AllTestz/main.swift
@@ -573,6 +573,8 @@ final class DriverTest_ : DriverTest, RxTestCase {
     ("testDriverFromOptionalWhenNil", DriverTest.testDriverFromOptionalWhenNil),
     ("testDriverFromSequence", DriverTest.testDriverFromSequence),
     ("testDriverFromArray", DriverTest.testDriverFromArray),
+    ("testDrivingOrderOfSynchronousSubscriptions1", DriverTest.testDrivingOrderOfSynchronousSubscriptions1),
+    ("testDrivingOrderOfSynchronousSubscriptions2", DriverTest.testDrivingOrderOfSynchronousSubscriptions2),
     ] }
 }
 
diff --git a/Tests/RxCocoaTests/Driver+Test.swift b/Tests/RxCocoaTests/Driver+Test.swift
@@ -1159,7 +1159,7 @@ extension DriverTest {
 
             XCTAssertTrue(hotObservable1.subscriptions == [UnsunscribedFromHotObservable])
         }
-        
+
         XCTAssertEqual(results, [2, -1])
     }
 }
@@ -1375,7 +1375,7 @@ extension DriverTest {
                 ])
         }
     }
-    
+
     func testDriverFromArray() {
         let scheduler = TestScheduler(initialClock: 0)
 
@@ -1388,3 +1388,72 @@ extension DriverTest {
         }
     }
 }
+
+// MARK: correct order of sync subscriptions
+
+extension DriverTest {
+    func testDrivingOrderOfSynchronousSubscriptions1() {
+        func prepareSampleDriver(with item: String) -> Driver<String> {
+            return Observable.create { observer in
+                    observer.onNext(item)
+                    observer.onCompleted()
+                    return Disposables.create()
+                }
+                .asDriver(onErrorJustReturn: "")
+        }
+
+        var disposeBag = DisposeBag()
+        let scheduler = TestScheduler(initialClock: 0)
+        let observer = scheduler.createObserver(String.self)
+        let variable = Variable("initial")
+
+        variable.asDriver()
+            .drive(observer)
+            .disposed(by: disposeBag)
+
+        prepareSampleDriver(with: "first")
+            .drive(variable)
+            .disposed(by: disposeBag)
+
+        prepareSampleDriver(with: "second")
+            .drive(variable)
+            .disposed(by: disposeBag)
+
+        Observable.just("third")
+            .bind(to: variable)
+            .disposed(by: disposeBag)
+
+        disposeBag = DisposeBag()
+
+        XCTAssertEqual(observer.events, [
+            next(0, "initial"),
+            next(0, "first"),
+            next(0, "second"),
+            next(0, "third")
+            ])
+
+    }
+
+    func testDrivingOrderOfSynchronousSubscriptions2() {
+        var latestValue: Int?
+        let state = Variable(1)
+        _ = state.asDriver()
+            .flatMapLatest { x in
+                return Driver.just(x * 2)
+            }
+            .flatMapLatest { y in
+                return Observable.just(y).asDriver(onErrorJustReturn: -1)
+            }
+            .flatMapLatest { y in
+                return Observable.just(y).asDriver(onErrorDriveWith: Driver.empty())
+            }
+            .flatMapLatest { y in
+                return Observable.just(y).asDriver(onErrorRecover: {  _ in Driver.empty() })
+            }
+            .drive(onNext: { element in
+                latestValue = element
+            })
+
+        XCTAssertEqual(latestValue, 2)
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -573,6 +573,8 @@ final class DriverTest_ : DriverTest, RxTestCase {`
`573`	`573`	`("testDriverFromOptionalWhenNil", DriverTest.testDriverFromOptionalWhenNil),`
`574`	`574`	`("testDriverFromSequence", DriverTest.testDriverFromSequence),`
`575`	`575`	`("testDriverFromArray", DriverTest.testDriverFromArray),`
	`576`	`+ ("testDrivingOrderOfSynchronousSubscriptions1", DriverTest.testDrivingOrderOfSynchronousSubscriptions1),`
	`577`	`+ ("testDrivingOrderOfSynchronousSubscriptions2", DriverTest.testDrivingOrderOfSynchronousSubscriptions2),`
`576`	`578`	`] }`
`577`	`579`	`}`
`578`	`580`