Add Using operator tests

RxSwift/Observables/Implementations/Using.swift

@@ -26,7 +26,7 @@ class UsingSink<SourceType, ResourceType: Disposable, O: ObserverType where O.E
         do {
             let resource = try _parent._resourceFactory()
             disposable = resource
-            let source = try _parent._observableFactory(resource: resource)
+            let source = try _parent._observableFactory(resource)
             
             return StableCompositeDisposable.create(
                 source.subscribeSafe(self),
@@ -59,7 +59,7 @@ class Using<SourceType, ResourceType: Disposable>: Producer<SourceType> {
     typealias E = SourceType
     
     typealias ResourceFactory = () throws -> ResourceType
-    typealias ObservableFactory = (resource: ResourceType) throws -> Observable<SourceType>
+    typealias ObservableFactory = ResourceType throws -> Observable<SourceType>
     
     private let _resourceFactory: ResourceFactory
     private let _observableFactory: ObservableFactory

RxTests/RxSwiftTests/TestImplementations/Mocks/MockDisposable.swift

@@ -0,0 +1,25 @@
+//
+//  MockDisposable.swift
+//  RxTests
+//
+//  Created by Yury Korolev on 10/17/15.
+//
+//
+
+import Foundation
+import RxSwift
+
+class MockDisposable : Disposable
+{
+    var ticks = [Int]()
+    private let _scheduler: TestScheduler
+    
+    init(scheduler: TestScheduler) {
+        _scheduler = scheduler
+        ticks.append(_scheduler.now)
+    }
+    
+    func dispose() {
+        ticks.append(_scheduler.now)
+    }
+}

RxTests/RxSwiftTests/Tests/Observable+CreationTest.swift

@@ -148,4 +148,248 @@ extension ObservableCreationTests {
             next(206, 42)
         ])
     }
+}
+
+// using
+extension ObservableCreationTests {
+    func testUsing_Null() {
+        let scheduler = TestScheduler(initialClock: 0)
+       
+        var disposeInvoked = 0
+        var createInvoked = 0
+       
+        var xs:ColdObservable<Int> = scheduler.createColdObservable([])
+        var disposable = MockDisposable(scheduler: scheduler)
+
+        var _d = MockDisposable(scheduler: scheduler)
+
+        let res = scheduler.start {
+            using({ () -> MockDisposable in
+                disposeInvoked += 1
+                disposable = MockDisposable(scheduler: scheduler)
+                return disposable
+                }, observableFactory: { d in
+                    _d = d
+                    createInvoked += 1
+                    xs = scheduler.createColdObservable([
+                        next(100, scheduler.clock),
+                        completed(200)
+                        ])
+                    return xs.asObservable()
+            }) as Observable<Int>
+        }
+        
+        XCTAssert(disposable === _d)
+        
+        XCTAssertEqual(res.messages, [
+            next(300, 200),
+            completed(400)
+        ])
+        
+        XCTAssertEqual(1, createInvoked)
+        XCTAssertEqual(1, disposeInvoked)
+        
+        XCTAssertEqual(xs.subscriptions, [
+            Subscription(200, 400)
+            ])
+        
+        // TODO: Assert.IsNull(disposable);
+    }
+    
+    func testUsing_Complete() {
+        let scheduler = TestScheduler(initialClock: 0)
+       
+        var disposeInvoked = 0
+        var createInvoked = 0
+       
+        var xs:ColdObservable<Int> = scheduler.createColdObservable([])
+        var disposable = MockDisposable(scheduler: scheduler)
+
+        var _d = MockDisposable(scheduler: scheduler)
+        
+        let res = scheduler.start {
+            using({ () -> MockDisposable in
+                disposeInvoked += 1
+                disposable = MockDisposable(scheduler: scheduler)
+                return disposable
+                }, observableFactory: { d in
+                    _d = d
+                    createInvoked += 1
+                    xs = scheduler.createColdObservable([
+                        next(100, scheduler.clock),
+                        completed(200)
+                        ])
+                    return xs.asObservable()
+            }) as Observable<Int>
+        }
+        
+        XCTAssert(disposable === _d)
+        
+        XCTAssertEqual(res.messages, [
+            next(300, 200),
+            completed(400)
+        ])
+        
+        XCTAssertEqual(1, createInvoked)
+        XCTAssertEqual(1, disposeInvoked)
+        
+        XCTAssertEqual(xs.subscriptions, [
+            Subscription(200, 400)
+            ])
+        
+        XCTAssertEqual(disposable.ticks, [
+            200,
+            400
+            ])
+    }
+    
+    func testUsing_Error() {
+        let scheduler = TestScheduler(initialClock: 0)
+       
+        var disposeInvoked = 0
+        var createInvoked = 0
+       
+        var xs:ColdObservable<Int> = scheduler.createColdObservable([])
+        var disposable = MockDisposable(scheduler: scheduler)
+
+        var _d = MockDisposable(scheduler: scheduler)
+        
+        let res = scheduler.start {
+            using({ () -> MockDisposable in
+                disposeInvoked += 1
+                disposable = MockDisposable(scheduler: scheduler)
+                return disposable
+                }, observableFactory: { d in
+                    _d = d
+                    createInvoked += 1
+                    xs = scheduler.createColdObservable([
+                        next(100, scheduler.clock),
+                        error(200, testError)
+                        ])
+                    return xs.asObservable()
+            }) as Observable<Int>
+        }
+        
+        XCTAssert(disposable === _d)
+        
+        XCTAssertEqual(res.messages, [
+            next(300, 200),
+            error(400, testError)
+        ])
+        
+        XCTAssertEqual(1, createInvoked)
+        XCTAssertEqual(1, disposeInvoked)
+        
+        XCTAssertEqual(xs.subscriptions, [
+            Subscription(200, 400)
+            ])
+        
+        XCTAssertEqual(disposable.ticks, [
+            200,
+            400
+            ])
+    }
+    
+    func testUsing_Dispose() {
+        let scheduler = TestScheduler(initialClock: 0)
+       
+        var disposeInvoked = 0
+        var createInvoked = 0
+       
+        var xs:ColdObservable<Int> = scheduler.createColdObservable([])
+        var disposable = MockDisposable(scheduler: scheduler)
+
+        var _d = MockDisposable(scheduler: scheduler)
+        
+        let res = scheduler.start {
+            using({ () -> MockDisposable in
+                disposeInvoked += 1
+                disposable = MockDisposable(scheduler: scheduler)
+                return disposable
+                }, observableFactory: { d in
+                    _d = d
+                    createInvoked += 1
+                    xs = scheduler.createColdObservable([
+                        next(100, scheduler.clock),
+                        next(1000, scheduler.clock + 1)
+                        ])
+                    return xs.asObservable()
+            }) as Observable<Int>
+        }
+        
+        XCTAssert(disposable === _d)
+        
+        XCTAssertEqual(res.messages, [
+            next(300, 200),
+        ])
+        
+        XCTAssertEqual(1, createInvoked)
+        XCTAssertEqual(1, disposeInvoked)
+        
+        XCTAssertEqual(xs.subscriptions, [
+            Subscription(200, 1000)
+            ])
+        
+        XCTAssertEqual(disposable.ticks, [
+            200,
+            1000
+            ])
+    }
+    
+    func testUsing_ThrowResourceSelector() {
+        let scheduler = TestScheduler(initialClock: 0)
+       
+        var disposeInvoked = 0
+        var createInvoked = 0
+       
+        let res = scheduler.start {
+            using({ () -> MockDisposable in
+                disposeInvoked += 1
+                throw testError
+                }, observableFactory: { d in
+                    createInvoked += 1
+                    return never()
+                    
+            }) as Observable<Int>
+        }
+        
+        XCTAssertEqual(res.messages, [
+            error(200, testError),
+        ])
+        
+        XCTAssertEqual(0, createInvoked)
+        XCTAssertEqual(1, disposeInvoked)
+    }
+    
+    func testUsing_ThrowResourceUsage() {
+        let scheduler = TestScheduler(initialClock: 0)
+       
+        var disposeInvoked = 0
+        var createInvoked = 0
+        var disposable = MockDisposable(scheduler: scheduler)
+       
+        let res = scheduler.start {
+            using({ () -> MockDisposable in
+                disposeInvoked += 1
+                disposable = MockDisposable(scheduler: scheduler)
+                return disposable
+                }, observableFactory: { d in
+                    createInvoked += 1
+                    throw testError
+                    
+            }) as Observable<Int>
+        }
+        
+        XCTAssertEqual(res.messages, [
+            error(200, testError),
+        ])
+        
+        XCTAssertEqual(1, createInvoked)
+        XCTAssertEqual(1, disposeInvoked)
+        
+        XCTAssertEqual(disposable.ticks, [
+            200,
+            200
+            ])
+    }
 }

RxTests/RxTests.xcodeproj/project.pbxproj

@@ -124,6 +124,7 @@
 		D203C4F01BB9C22800D02D00 /* NSObject+RxTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = C81CC92A1B513FD400915606 /* NSObject+RxTests.swift */; };
 		D203C5141BB9C54A00D02D00 /* UIControl+RxTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5E5D10BA1B48355200432B25 /* UIControl+RxTests.swift */; };
 		D251ED291BB9BF90002D0E36 /* RxCocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = C8A468CC1B8A897800BF917B /* RxCocoa.framework */; };
+		D2AF91971BD2EBB900A008C1 /* MockDisposable.swift in Sources */ = {isa = PBXBuildFile; fileRef = D2AF91961BD2EBB900A008C1 /* MockDisposable.swift */; };
 		D2EBEB521BB9B7CC003A27DC /* ColdObservable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C81108301AF50E2A001C13E4 /* ColdObservable.swift */; };
 		D2EBEB531BB9B7CC003A27DC /* TestConnectableObservable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C81108311AF50E2A001C13E4 /* TestConnectableObservable.swift */; };
 		D2EBEB541BB9B7CC003A27DC /* HotObservable.swift in Sources */ = {isa = PBXBuildFile; fileRef = C81108321AF50E2A001C13E4 /* HotObservable.swift */; };
@@ -230,6 +231,7 @@
 		C8E3812A1B2083C2008CDC33 /* PrimitiveMockObserver.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = PrimitiveMockObserver.swift; sourceTree = "<group>"; };
 		C8EA2D361BD02E1900FB22AC /* EquatableArray.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = EquatableArray.swift; sourceTree = "<group>"; };
 		C8FDC5F71B2B5B7E0065F8D9 /* ElementIndexPair.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ElementIndexPair.swift; sourceTree = "<group>"; };
+		D2AF91961BD2EBB900A008C1 /* MockDisposable.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = MockDisposable.swift; sourceTree = "<group>"; };
 		D2EBEB491BB9B7AE003A27DC /* RxTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RxTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
 /* End PBXFileReference section */
 
@@ -367,6 +369,7 @@
 				C8E381271B207D03008CDC33 /* PrimitiveHotObservable.swift */,
 				C8E3812A1B2083C2008CDC33 /* PrimitiveMockObserver.swift */,
 				C80DDEDF1BCEE898006A1832 /* MainThreadPrimitiveHotObservable.swift */,
+				D2AF91961BD2EBB900A008C1 /* MockDisposable.swift */,
 			);
 			path = Mocks;
 			sourceTree = "<group>";
@@ -608,6 +611,7 @@
 				C81108651AF50E2A001C13E4 /* Observable+SingleTest.swift in Sources */,
 				5E5D10BB1B48355200432B25 /* UIControl+RxTests.swift in Sources */,
 				C897EC4A1B1123DA009C2CB0 /* Observable+MultipleTest+Zip.swift in Sources */,
+				D2AF91971BD2EBB900A008C1 /* MockDisposable.swift in Sources */,
 				C81108571AF50E2A001C13E4 /* Recorded.swift in Sources */,
 				C801EB5A1B97951100C4D8C4 /* Observable+CreationTest.swift in Sources */,
 				C81108591AF50E2A001C13E4 /* TestScheduler.swift in Sources */,